godotengine/godot-docs-l10n
1
0
Fork 0
mirror of https://github.com/godotengine/godot-docs-l10n.git synced 2025-12-31 09:49:22 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
4.x
godot-docs-l10n/classes/it/class_canvasitem.rst
Rémi Verschelde c3f2364c10 Sync classref with 4.6 branch 
Lots of translations invalidated (fuzzied) as we just synced Weblate.
2025-12-19 16:39:51 +01:00

1689 lines
200 KiB
ReStructuredText
Raw Permalink Blame History

This file contains ambiguous Unicode characters

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

:github_url: hide
.. _class_CanvasItem:
CanvasItem
==========
**Eredita:** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
**Ereditato da:** :ref:`Control<class_Control>`, :ref:`Node2D<class_Node2D>`
Classe di base astratta per ogni nodo nello spazio 2D.
.. rst-class:: classref-introduction-group
Descrizione
----------------------
Classe base astratta per tutto ciò che si trova nello spazio 2D. Gli elementi canvas sono disposti in un albero; i figli ereditano ed estendono la trasformazione del genitore. **CanvasItem** è esteso da :ref:`Control<class_Control>` per i nodi che riguardano la GUI e da :ref:`Node2D<class_Node2D>` per gli oggetti di gioco 2D.
Qualsiasi **CanvasItem** può disegnare. Per fare ciò, il motore chiama :ref:`queue_redraw()<class_CanvasItem_method_queue_redraw>`, quindi :ref:`NOTIFICATION_DRAW<class_CanvasItem_constant_NOTIFICATION_DRAW>` sarà ricevuto durante il tempo di inattività per richiedere un ridisegno. Per questo motivo, gli elementi canvas non hanno bisogno di ridisegnarsi a ogni frame, migliorando notevolmente le prestazioni. Sono disponibili diverse funzioni per disegnare su **CanvasItem** (consulare le funzioni ``draw_*``). Tuttavia, è solo possibile utilizzarle all'interno di :ref:`_draw()<class_CanvasItem_private_method__draw>`, della sua notifica corrispondente (:ref:`Object._notification()<class_Object_private_method__notification>`) o di metodi connessi al segnale :ref:`draw<class_CanvasItem_signal_draw>`.
Gli elementi canvas sono disegnati in ordine ad albero sul loro livello canvas. Come predefinito, i figli si trovano sopra i genitori, quindi un **CanvasItem** radice sarà disegnato dietro tutto. È possibile cambiare questo comportamento per ogni singolo elemento.
Un **CanvasItem** può essere nascosto, nascondendo così anche i suoi figli. Cambiando varie altre proprietà di un **CanvasItem**, è anche possibile modularne il colore (tramite :ref:`modulate<class_CanvasItem_property_modulate>` o :ref:`self_modulate<class_CanvasItem_property_self_modulate>`), modificarne l'indice Z, la modalità di fusione e altro ancora.
Si noti che proprietà come trasformazione, modulazione e visibilità sono propagate solo ai nodi **CanvasItem** figlio *diretti*. Se è presente un nodo non **CanvasItem** intermedio, come :ref:`Node<class_Node>` o :ref:`AnimationPlayer<class_AnimationPlayer>`, i nodi **CanvasItem** sottostanti avranno una "catena" indipendente per la posizione e per :ref:`modulate<class_CanvasItem_property_modulate>`. Vedi anche :ref:`top_level<class_CanvasItem_property_top_level>`.
.. rst-class:: classref-introduction-group
Tutorial
----------------
- :doc:`Viewport e trasformazioni di canvas <../tutorials/2d/2d_transforms>`
- :doc:`Disegno personalizzato in 2D <../tutorials/2d/custom_drawing_in_2d>`
- `Demo di visualizzatore spettro audio <https://godotengine.org/asset-library/asset/2762>`__
.. rst-class:: classref-reftable-group
Proprietà
------------------
.. table::
:widths: auto
+-----------------------------------------------------------+---------------------------------------------------------------------------+-----------------------+
| :ref:`ClipChildrenMode<enum_CanvasItem_ClipChildrenMode>` | :ref:`clip_children<class_CanvasItem_property_clip_children>` | ``0`` |
+-----------------------------------------------------------+---------------------------------------------------------------------------+-----------------------+
| :ref:`int<class_int>` | :ref:`light_mask<class_CanvasItem_property_light_mask>` | ``1`` |
+-----------------------------------------------------------+---------------------------------------------------------------------------+-----------------------+
| :ref:`Material<class_Material>` | :ref:`material<class_CanvasItem_property_material>` | |
+-----------------------------------------------------------+---------------------------------------------------------------------------+-----------------------+
| :ref:`Color<class_Color>` | :ref:`modulate<class_CanvasItem_property_modulate>` | ``Color(1, 1, 1, 1)`` |
+-----------------------------------------------------------+---------------------------------------------------------------------------+-----------------------+
| :ref:`Color<class_Color>` | :ref:`self_modulate<class_CanvasItem_property_self_modulate>` | ``Color(1, 1, 1, 1)`` |
+-----------------------------------------------------------+---------------------------------------------------------------------------+-----------------------+
| :ref:`bool<class_bool>` | :ref:`show_behind_parent<class_CanvasItem_property_show_behind_parent>` | ``false`` |
+-----------------------------------------------------------+---------------------------------------------------------------------------+-----------------------+
| :ref:`TextureFilter<enum_CanvasItem_TextureFilter>` | :ref:`texture_filter<class_CanvasItem_property_texture_filter>` | ``0`` |
+-----------------------------------------------------------+---------------------------------------------------------------------------+-----------------------+
| :ref:`TextureRepeat<enum_CanvasItem_TextureRepeat>` | :ref:`texture_repeat<class_CanvasItem_property_texture_repeat>` | ``0`` |
+-----------------------------------------------------------+---------------------------------------------------------------------------+-----------------------+
| :ref:`bool<class_bool>` | :ref:`top_level<class_CanvasItem_property_top_level>` | ``false`` |
+-----------------------------------------------------------+---------------------------------------------------------------------------+-----------------------+
| :ref:`bool<class_bool>` | :ref:`use_parent_material<class_CanvasItem_property_use_parent_material>` | ``false`` |
+-----------------------------------------------------------+---------------------------------------------------------------------------+-----------------------+
| :ref:`int<class_int>` | :ref:`visibility_layer<class_CanvasItem_property_visibility_layer>` | ``1`` |
+-----------------------------------------------------------+---------------------------------------------------------------------------+-----------------------+
| :ref:`bool<class_bool>` | :ref:`visible<class_CanvasItem_property_visible>` | ``true`` |
+-----------------------------------------------------------+---------------------------------------------------------------------------+-----------------------+
| :ref:`bool<class_bool>` | :ref:`y_sort_enabled<class_CanvasItem_property_y_sort_enabled>` | ``false`` |
+-----------------------------------------------------------+---------------------------------------------------------------------------+-----------------------+
| :ref:`bool<class_bool>` | :ref:`z_as_relative<class_CanvasItem_property_z_as_relative>` | ``true`` |
+-----------------------------------------------------------+---------------------------------------------------------------------------+-----------------------+
| :ref:`int<class_int>` | :ref:`z_index<class_CanvasItem_property_z_index>` | ``0`` |
+-----------------------------------------------------------+---------------------------------------------------------------------------+-----------------------+
.. rst-class:: classref-reftable-group
Metodi
------------
.. table::
:widths: auto
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`_draw<class_CanvasItem_private_method__draw>`\ (\ ) |virtual| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_animation_slice<class_CanvasItem_method_draw_animation_slice>`\ (\ animation_length\: :ref:`float<class_float>`, slice_begin\: :ref:`float<class_float>`, slice_end\: :ref:`float<class_float>`, offset\: :ref:`float<class_float>` = 0.0\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_arc<class_CanvasItem_method_draw_arc>`\ (\ center\: :ref:`Vector2<class_Vector2>`, radius\: :ref:`float<class_float>`, start_angle\: :ref:`float<class_float>`, end_angle\: :ref:`float<class_float>`, point_count\: :ref:`int<class_int>`, color\: :ref:`Color<class_Color>`, width\: :ref:`float<class_float>` = -1.0, antialiased\: :ref:`bool<class_bool>` = false\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_char<class_CanvasItem_method_draw_char>`\ (\ font\: :ref:`Font<class_Font>`, pos\: :ref:`Vector2<class_Vector2>`, char\: :ref:`String<class_String>`, font_size\: :ref:`int<class_int>` = 16, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1), oversampling\: :ref:`float<class_float>` = 0.0\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_char_outline<class_CanvasItem_method_draw_char_outline>`\ (\ font\: :ref:`Font<class_Font>`, pos\: :ref:`Vector2<class_Vector2>`, char\: :ref:`String<class_String>`, font_size\: :ref:`int<class_int>` = 16, size\: :ref:`int<class_int>` = -1, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1), oversampling\: :ref:`float<class_float>` = 0.0\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_circle<class_CanvasItem_method_draw_circle>`\ (\ position\: :ref:`Vector2<class_Vector2>`, radius\: :ref:`float<class_float>`, color\: :ref:`Color<class_Color>`, filled\: :ref:`bool<class_bool>` = true, width\: :ref:`float<class_float>` = -1.0, antialiased\: :ref:`bool<class_bool>` = false\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_colored_polygon<class_CanvasItem_method_draw_colored_polygon>`\ (\ points\: :ref:`PackedVector2Array<class_PackedVector2Array>`, color\: :ref:`Color<class_Color>`, uvs\: :ref:`PackedVector2Array<class_PackedVector2Array>` = PackedVector2Array(), texture\: :ref:`Texture2D<class_Texture2D>` = null\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_dashed_line<class_CanvasItem_method_draw_dashed_line>`\ (\ from\: :ref:`Vector2<class_Vector2>`, to\: :ref:`Vector2<class_Vector2>`, color\: :ref:`Color<class_Color>`, width\: :ref:`float<class_float>` = -1.0, dash\: :ref:`float<class_float>` = 2.0, aligned\: :ref:`bool<class_bool>` = true, antialiased\: :ref:`bool<class_bool>` = false\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_ellipse<class_CanvasItem_method_draw_ellipse>`\ (\ position\: :ref:`Vector2<class_Vector2>`, major\: :ref:`float<class_float>`, minor\: :ref:`float<class_float>`, color\: :ref:`Color<class_Color>`, filled\: :ref:`bool<class_bool>` = true, width\: :ref:`float<class_float>` = -1.0, antialiased\: :ref:`bool<class_bool>` = false\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_ellipse_arc<class_CanvasItem_method_draw_ellipse_arc>`\ (\ center\: :ref:`Vector2<class_Vector2>`, major\: :ref:`float<class_float>`, minor\: :ref:`float<class_float>`, start_angle\: :ref:`float<class_float>`, end_angle\: :ref:`float<class_float>`, point_count\: :ref:`int<class_int>`, color\: :ref:`Color<class_Color>`, width\: :ref:`float<class_float>` = -1.0, antialiased\: :ref:`bool<class_bool>` = false\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_end_animation<class_CanvasItem_method_draw_end_animation>`\ (\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_lcd_texture_rect_region<class_CanvasItem_method_draw_lcd_texture_rect_region>`\ (\ texture\: :ref:`Texture2D<class_Texture2D>`, rect\: :ref:`Rect2<class_Rect2>`, src_rect\: :ref:`Rect2<class_Rect2>`, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1)\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_line<class_CanvasItem_method_draw_line>`\ (\ from\: :ref:`Vector2<class_Vector2>`, to\: :ref:`Vector2<class_Vector2>`, color\: :ref:`Color<class_Color>`, width\: :ref:`float<class_float>` = -1.0, antialiased\: :ref:`bool<class_bool>` = false\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_mesh<class_CanvasItem_method_draw_mesh>`\ (\ mesh\: :ref:`Mesh<class_Mesh>`, texture\: :ref:`Texture2D<class_Texture2D>`, transform\: :ref:`Transform2D<class_Transform2D>` = Transform2D(1, 0, 0, 1, 0, 0), modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1)\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_msdf_texture_rect_region<class_CanvasItem_method_draw_msdf_texture_rect_region>`\ (\ texture\: :ref:`Texture2D<class_Texture2D>`, rect\: :ref:`Rect2<class_Rect2>`, src_rect\: :ref:`Rect2<class_Rect2>`, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1), outline\: :ref:`float<class_float>` = 0.0, pixel_range\: :ref:`float<class_float>` = 4.0, scale\: :ref:`float<class_float>` = 1.0\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_multiline<class_CanvasItem_method_draw_multiline>`\ (\ points\: :ref:`PackedVector2Array<class_PackedVector2Array>`, color\: :ref:`Color<class_Color>`, width\: :ref:`float<class_float>` = -1.0, antialiased\: :ref:`bool<class_bool>` = false\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_multiline_colors<class_CanvasItem_method_draw_multiline_colors>`\ (\ points\: :ref:`PackedVector2Array<class_PackedVector2Array>`, colors\: :ref:`PackedColorArray<class_PackedColorArray>`, width\: :ref:`float<class_float>` = -1.0, antialiased\: :ref:`bool<class_bool>` = false\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_multiline_string<class_CanvasItem_method_draw_multiline_string>`\ (\ font\: :ref:`Font<class_Font>`, pos\: :ref:`Vector2<class_Vector2>`, text\: :ref:`String<class_String>`, alignment\: :ref:`HorizontalAlignment<enum_@GlobalScope_HorizontalAlignment>` = 0, width\: :ref:`float<class_float>` = -1, font_size\: :ref:`int<class_int>` = 16, max_lines\: :ref:`int<class_int>` = -1, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1), brk_flags\: |bitfield|\[:ref:`LineBreakFlag<enum_TextServer_LineBreakFlag>`\] = 3, justification_flags\: |bitfield|\[:ref:`JustificationFlag<enum_TextServer_JustificationFlag>`\] = 3, direction\: :ref:`Direction<enum_TextServer_Direction>` = 0, orientation\: :ref:`Orientation<enum_TextServer_Orientation>` = 0, oversampling\: :ref:`float<class_float>` = 0.0\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_multiline_string_outline<class_CanvasItem_method_draw_multiline_string_outline>`\ (\ font\: :ref:`Font<class_Font>`, pos\: :ref:`Vector2<class_Vector2>`, text\: :ref:`String<class_String>`, alignment\: :ref:`HorizontalAlignment<enum_@GlobalScope_HorizontalAlignment>` = 0, width\: :ref:`float<class_float>` = -1, font_size\: :ref:`int<class_int>` = 16, max_lines\: :ref:`int<class_int>` = -1, size\: :ref:`int<class_int>` = 1, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1), brk_flags\: |bitfield|\[:ref:`LineBreakFlag<enum_TextServer_LineBreakFlag>`\] = 3, justification_flags\: |bitfield|\[:ref:`JustificationFlag<enum_TextServer_JustificationFlag>`\] = 3, direction\: :ref:`Direction<enum_TextServer_Direction>` = 0, orientation\: :ref:`Orientation<enum_TextServer_Orientation>` = 0, oversampling\: :ref:`float<class_float>` = 0.0\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_multimesh<class_CanvasItem_method_draw_multimesh>`\ (\ multimesh\: :ref:`MultiMesh<class_MultiMesh>`, texture\: :ref:`Texture2D<class_Texture2D>`\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_polygon<class_CanvasItem_method_draw_polygon>`\ (\ points\: :ref:`PackedVector2Array<class_PackedVector2Array>`, colors\: :ref:`PackedColorArray<class_PackedColorArray>`, uvs\: :ref:`PackedVector2Array<class_PackedVector2Array>` = PackedVector2Array(), texture\: :ref:`Texture2D<class_Texture2D>` = null\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_polyline<class_CanvasItem_method_draw_polyline>`\ (\ points\: :ref:`PackedVector2Array<class_PackedVector2Array>`, color\: :ref:`Color<class_Color>`, width\: :ref:`float<class_float>` = -1.0, antialiased\: :ref:`bool<class_bool>` = false\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_polyline_colors<class_CanvasItem_method_draw_polyline_colors>`\ (\ points\: :ref:`PackedVector2Array<class_PackedVector2Array>`, colors\: :ref:`PackedColorArray<class_PackedColorArray>`, width\: :ref:`float<class_float>` = -1.0, antialiased\: :ref:`bool<class_bool>` = false\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_primitive<class_CanvasItem_method_draw_primitive>`\ (\ points\: :ref:`PackedVector2Array<class_PackedVector2Array>`, colors\: :ref:`PackedColorArray<class_PackedColorArray>`, uvs\: :ref:`PackedVector2Array<class_PackedVector2Array>`, texture\: :ref:`Texture2D<class_Texture2D>` = null\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_rect<class_CanvasItem_method_draw_rect>`\ (\ rect\: :ref:`Rect2<class_Rect2>`, color\: :ref:`Color<class_Color>`, filled\: :ref:`bool<class_bool>` = true, width\: :ref:`float<class_float>` = -1.0, antialiased\: :ref:`bool<class_bool>` = false\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_set_transform<class_CanvasItem_method_draw_set_transform>`\ (\ position\: :ref:`Vector2<class_Vector2>`, rotation\: :ref:`float<class_float>` = 0.0, scale\: :ref:`Vector2<class_Vector2>` = Vector2(1, 1)\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_set_transform_matrix<class_CanvasItem_method_draw_set_transform_matrix>`\ (\ xform\: :ref:`Transform2D<class_Transform2D>`\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_string<class_CanvasItem_method_draw_string>`\ (\ font\: :ref:`Font<class_Font>`, pos\: :ref:`Vector2<class_Vector2>`, text\: :ref:`String<class_String>`, alignment\: :ref:`HorizontalAlignment<enum_@GlobalScope_HorizontalAlignment>` = 0, width\: :ref:`float<class_float>` = -1, font_size\: :ref:`int<class_int>` = 16, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1), justification_flags\: |bitfield|\[:ref:`JustificationFlag<enum_TextServer_JustificationFlag>`\] = 3, direction\: :ref:`Direction<enum_TextServer_Direction>` = 0, orientation\: :ref:`Orientation<enum_TextServer_Orientation>` = 0, oversampling\: :ref:`float<class_float>` = 0.0\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_string_outline<class_CanvasItem_method_draw_string_outline>`\ (\ font\: :ref:`Font<class_Font>`, pos\: :ref:`Vector2<class_Vector2>`, text\: :ref:`String<class_String>`, alignment\: :ref:`HorizontalAlignment<enum_@GlobalScope_HorizontalAlignment>` = 0, width\: :ref:`float<class_float>` = -1, font_size\: :ref:`int<class_int>` = 16, size\: :ref:`int<class_int>` = 1, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1), justification_flags\: |bitfield|\[:ref:`JustificationFlag<enum_TextServer_JustificationFlag>`\] = 3, direction\: :ref:`Direction<enum_TextServer_Direction>` = 0, orientation\: :ref:`Orientation<enum_TextServer_Orientation>` = 0, oversampling\: :ref:`float<class_float>` = 0.0\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_style_box<class_CanvasItem_method_draw_style_box>`\ (\ style_box\: :ref:`StyleBox<class_StyleBox>`, rect\: :ref:`Rect2<class_Rect2>`\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_texture<class_CanvasItem_method_draw_texture>`\ (\ texture\: :ref:`Texture2D<class_Texture2D>`, position\: :ref:`Vector2<class_Vector2>`, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1)\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_texture_rect<class_CanvasItem_method_draw_texture_rect>`\ (\ texture\: :ref:`Texture2D<class_Texture2D>`, rect\: :ref:`Rect2<class_Rect2>`, tile\: :ref:`bool<class_bool>`, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1), transpose\: :ref:`bool<class_bool>` = false\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_texture_rect_region<class_CanvasItem_method_draw_texture_rect_region>`\ (\ texture\: :ref:`Texture2D<class_Texture2D>`, rect\: :ref:`Rect2<class_Rect2>`, src_rect\: :ref:`Rect2<class_Rect2>`, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1), transpose\: :ref:`bool<class_bool>` = false, clip_uv\: :ref:`bool<class_bool>` = true\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`force_update_transform<class_CanvasItem_method_force_update_transform>`\ (\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`get_canvas<class_CanvasItem_method_get_canvas>`\ (\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`get_canvas_item<class_CanvasItem_method_get_canvas_item>`\ (\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`CanvasLayer<class_CanvasLayer>` | :ref:`get_canvas_layer_node<class_CanvasItem_method_get_canvas_layer_node>`\ (\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Transform2D<class_Transform2D>` | :ref:`get_canvas_transform<class_CanvasItem_method_get_canvas_transform>`\ (\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`get_global_mouse_position<class_CanvasItem_method_get_global_mouse_position>`\ (\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Transform2D<class_Transform2D>` | :ref:`get_global_transform<class_CanvasItem_method_get_global_transform>`\ (\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Transform2D<class_Transform2D>` | :ref:`get_global_transform_with_canvas<class_CanvasItem_method_get_global_transform_with_canvas>`\ (\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Variant<class_Variant>` | :ref:`get_instance_shader_parameter<class_CanvasItem_method_get_instance_shader_parameter>`\ (\ name\: :ref:`StringName<class_StringName>`\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`get_local_mouse_position<class_CanvasItem_method_get_local_mouse_position>`\ (\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Transform2D<class_Transform2D>` | :ref:`get_screen_transform<class_CanvasItem_method_get_screen_transform>`\ (\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Transform2D<class_Transform2D>` | :ref:`get_transform<class_CanvasItem_method_get_transform>`\ (\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Rect2<class_Rect2>` | :ref:`get_viewport_rect<class_CanvasItem_method_get_viewport_rect>`\ (\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Transform2D<class_Transform2D>` | :ref:`get_viewport_transform<class_CanvasItem_method_get_viewport_transform>`\ (\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`get_visibility_layer_bit<class_CanvasItem_method_get_visibility_layer_bit>`\ (\ layer\: :ref:`int<class_int>`\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`World2D<class_World2D>` | :ref:`get_world_2d<class_CanvasItem_method_get_world_2d>`\ (\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`hide<class_CanvasItem_method_hide>`\ (\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_local_transform_notification_enabled<class_CanvasItem_method_is_local_transform_notification_enabled>`\ (\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_transform_notification_enabled<class_CanvasItem_method_is_transform_notification_enabled>`\ (\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_visible_in_tree<class_CanvasItem_method_is_visible_in_tree>`\ (\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`make_canvas_position_local<class_CanvasItem_method_make_canvas_position_local>`\ (\ viewport_point\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`InputEvent<class_InputEvent>` | :ref:`make_input_local<class_CanvasItem_method_make_input_local>`\ (\ event\: :ref:`InputEvent<class_InputEvent>`\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`move_to_front<class_CanvasItem_method_move_to_front>`\ (\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`queue_redraw<class_CanvasItem_method_queue_redraw>`\ (\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_instance_shader_parameter<class_CanvasItem_method_set_instance_shader_parameter>`\ (\ name\: :ref:`StringName<class_StringName>`, value\: :ref:`Variant<class_Variant>`\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_notify_local_transform<class_CanvasItem_method_set_notify_local_transform>`\ (\ enable\: :ref:`bool<class_bool>`\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_notify_transform<class_CanvasItem_method_set_notify_transform>`\ (\ enable\: :ref:`bool<class_bool>`\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_visibility_layer_bit<class_CanvasItem_method_set_visibility_layer_bit>`\ (\ layer\: :ref:`int<class_int>`, enabled\: :ref:`bool<class_bool>`\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`show<class_CanvasItem_method_show>`\ (\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Segnali
--------------
.. _class_CanvasItem_signal_draw:
.. rst-class:: classref-signal
**draw**\ (\ ) :ref:`🔗<class_CanvasItem_signal_draw>`
Emesso quando il **CanvasItem** deve essere ridisegnato, *dopo* la relativa notifica :ref:`NOTIFICATION_DRAW<class_CanvasItem_constant_NOTIFICATION_DRAW>` e *prima* che viene chiamato :ref:`_draw()<class_CanvasItem_private_method__draw>`.
\ **Nota:** Le connessioni differite non consentono il disegno tramite i metodi ``draw_*``.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_signal_hidden:
.. rst-class:: classref-signal
**hidden**\ (\ ) :ref:`🔗<class_CanvasItem_signal_hidden>`
Emesso quando questo nodo diventa nascosto, ovvero non è più visibile nell'albero (vedi :ref:`is_visible_in_tree()<class_CanvasItem_method_is_visible_in_tree>`).
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_signal_item_rect_changed:
.. rst-class:: classref-signal
**item_rect_changed**\ (\ ) :ref:`🔗<class_CanvasItem_signal_item_rect_changed>`
Emesso quando i confini :ref:`Rect2<class_Rect2>` del **CanvasItem** (posizione o dimensioni) sono cambiati o quando si svolge un'azione che potrebbe aver influito su tali confini (ad esempio la modifica di :ref:`Sprite2D.texture<class_Sprite2D_property_texture>`).
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_signal_visibility_changed:
.. rst-class:: classref-signal
**visibility_changed**\ (\ ) :ref:`🔗<class_CanvasItem_signal_visibility_changed>`
Emesso quando la visibilità del **CanvasItem** cambia, che sia perché è cambiata la sua proprietà :ref:`visible<class_CanvasItem_property_visible>` o perché è cambiata la sua visibilità nell'albero (vedi :ref:`is_visible_in_tree()<class_CanvasItem_method_is_visible_in_tree>`).
Questo segnale viene emesso *dopo* la notifica correlata :ref:`NOTIFICATION_VISIBILITY_CHANGED<class_CanvasItem_constant_NOTIFICATION_VISIBILITY_CHANGED>`.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Enumerazioni
------------------------
.. _enum_CanvasItem_TextureFilter:
.. rst-class:: classref-enumeration
enum **TextureFilter**: :ref:`🔗<enum_CanvasItem_TextureFilter>`
.. _class_CanvasItem_constant_TEXTURE_FILTER_PARENT_NODE:
.. rst-class:: classref-enumeration-constant
:ref:`TextureFilter<enum_CanvasItem_TextureFilter>` **TEXTURE_FILTER_PARENT_NODE** = ``0``
Il **CanvasItem** erediterà il filtro dal suo genitore.
.. _class_CanvasItem_constant_TEXTURE_FILTER_NEAREST:
.. rst-class:: classref-enumeration-constant
:ref:`TextureFilter<enum_CanvasItem_TextureFilter>` **TEXTURE_FILTER_NEAREST** = ``1``
Il filtro della texture legge solamente il pixel più vicino. Ciò rende la texture pixellata da vicino, e granulosa da lontano (poiché non sono campionate le mipmap).
.. _class_CanvasItem_constant_TEXTURE_FILTER_LINEAR:
.. rst-class:: classref-enumeration-constant
:ref:`TextureFilter<enum_CanvasItem_TextureFilter>` **TEXTURE_FILTER_LINEAR** = ``2``
Il filtro della texture fonde tra i 4 pixel più vicini. Ciò rende la texture liscia da vicino e granulosa da lontano (poiché non sono campionate le mipmap).
.. _class_CanvasItem_constant_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS:
.. rst-class:: classref-enumeration-constant
:ref:`TextureFilter<enum_CanvasItem_TextureFilter>` **TEXTURE_FILTER_NEAREST_WITH_MIPMAPS** = ``3``
Il filtro della texture legge dal pixel più vicino e lo fonde tra le 2 mipmap più vicine (o usa la mipmap più vicina se :ref:`ProjectSettings.rendering/textures/default_filters/use_nearest_mipmap_filter<class_ProjectSettings_property_rendering/textures/default_filters/use_nearest_mipmap_filter>` è ``true``). Ciò rende la texture pixelata da vicino, e liscia da lontano.
Usa questo filtro per texture non pixel art che potrebbero visualizzarsi a bassa scala (ad esempio a causa dello zoom :ref:`Camera2D<class_Camera2D>` o del ridimensionamento degli sprite), poiché le mipmap sono importanti per smussare i pixel più piccoli dei pixel sullo schermo.
.. _class_CanvasItem_constant_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS:
.. rst-class:: classref-enumeration-constant
:ref:`TextureFilter<enum_CanvasItem_TextureFilter>` **TEXTURE_FILTER_LINEAR_WITH_MIPMAPS** = ``4``
Il filtro della texture fonde tra i 4 pixel più vicini e tra le 2 mipmap più vicine (o usa la mipmap più vicina se :ref:`ProjectSettings.rendering/textures/default_filters/use_nearest_mipmap_filter<class_ProjectSettings_property_rendering/textures/default_filters/use_nearest_mipmap_filter>` è ``true``). Ciò rende la texture liscia da vicino, e liscia da lontano.
Usa questo filtro per texture non pixel art che potrebbero visualizzarsi a bassa scala (ad esempio a causa dello zoom :ref:`Camera2D<class_Camera2D>` o del ridimensionamento degli sprite), poiché le mipmap sono importanti per smussare i pixel più piccoli dei pixel sullo schermo.
.. _class_CanvasItem_constant_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC:
.. rst-class:: classref-enumeration-constant
:ref:`TextureFilter<enum_CanvasItem_TextureFilter>` **TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC** = ``5``
Il filtro della texture legge dal pixel più vicino e lo fonde tra le 2 mipmap più vicine (o usa la mipmap più vicina se :ref:`ProjectSettings.rendering/textures/default_filters/use_nearest_mipmap_filter<class_ProjectSettings_property_rendering/textures/default_filters/use_nearest_mipmap_filter>` è ``true``) a seconda dell'angolo tra la superficie e la vista della telecamera. Ciò rende la texture pixelata da vicino, e liscia da lontano. Il filtro anisotropico migliora la qualità delle texture sulle superfici quasi in linea con la telecamera, ma è leggermente più lento. Il livello di filtro anisotropico si può cambiare regolando :ref:`ProjectSettings.rendering/textures/default_filters/anisotropic_filtering_level<class_ProjectSettings_property_rendering/textures/default_filters/anisotropic_filtering_level>`.
\ **Nota:** Questo filtro di texture è raramente utile nei progetti 2D. :ref:`TEXTURE_FILTER_NEAREST_WITH_MIPMAPS<class_CanvasItem_constant_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS>` è solitamente più appropriato in questo caso.
.. _class_CanvasItem_constant_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC:
.. rst-class:: classref-enumeration-constant
:ref:`TextureFilter<enum_CanvasItem_TextureFilter>` **TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC** = ``6``
Il filtro della texture fonde tra i 4 pixel più vicini e tra le 2 mipmap più vicine (o usa la mipmap più vicina se :ref:`ProjectSettings.rendering/textures/default_filters/use_nearest_mipmap_filter<class_ProjectSettings_property_rendering/textures/default_filters/use_nearest_mipmap_filter>` è ``true``) a seconda dell'angolo tra la superficie e la vista della telecamera. Ciò rende la texture liscia da vicino, e liscia da lontano. Il filtro anisotropico migliora la qualità delle texture sulle superfici quasi in linea con la telecamera, ma è leggermente più lento. Il livello di filtro anisotropico si può cambiare regolando :ref:`ProjectSettings.rendering/textures/default_filters/anisotropic_filtering_level<class_ProjectSettings_property_rendering/textures/default_filters/anisotropic_filtering_level>`.
\ **Nota:** Questo filtro di texture è raramente utile nei progetti 2D. :ref:`TEXTURE_FILTER_LINEAR_WITH_MIPMAPS<class_CanvasItem_constant_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS>` è solitamente più appropriato in questo caso.
.. _class_CanvasItem_constant_TEXTURE_FILTER_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`TextureFilter<enum_CanvasItem_TextureFilter>` **TEXTURE_FILTER_MAX** = ``7``
Rappresenta la dimensione dell'enumerazione :ref:`TextureFilter<enum_CanvasItem_TextureFilter>`.
.. rst-class:: classref-item-separator
----
.. _enum_CanvasItem_TextureRepeat:
.. rst-class:: classref-enumeration
enum **TextureRepeat**: :ref:`🔗<enum_CanvasItem_TextureRepeat>`
.. _class_CanvasItem_constant_TEXTURE_REPEAT_PARENT_NODE:
.. rst-class:: classref-enumeration-constant
:ref:`TextureRepeat<enum_CanvasItem_TextureRepeat>` **TEXTURE_REPEAT_PARENT_NODE** = ``0``
Il **CanvasItem** erediterà il filtro dal suo genitore.
.. _class_CanvasItem_constant_TEXTURE_REPEAT_DISABLED:
.. rst-class:: classref-enumeration-constant
:ref:`TextureRepeat<enum_CanvasItem_TextureRepeat>` **TEXTURE_REPEAT_DISABLED** = ``1``
La texture non si ripete. Campionare la texture al di fuori dei suoi limiti produrrà uno "stiramento" dei pixel sul bordo. È possibile evitare ciò assicurandosi che ci sia un bordo di 1 pixel completamente trasparente su ciascun lato della texture.
.. _class_CanvasItem_constant_TEXTURE_REPEAT_ENABLED:
.. rst-class:: classref-enumeration-constant
:ref:`TextureRepeat<enum_CanvasItem_TextureRepeat>` **TEXTURE_REPEAT_ENABLED** = ``2``
La texture si ripete quando eccede le dimensioni della texture stessa.
.. _class_CanvasItem_constant_TEXTURE_REPEAT_MIRROR:
.. rst-class:: classref-enumeration-constant
:ref:`TextureRepeat<enum_CanvasItem_TextureRepeat>` **TEXTURE_REPEAT_MIRROR** = ``3``
La texture si ripete quando eccede le dimensioni della texture stessa, in una "modalità a piastrelle 2×2". Le texture ripetute alle posizioni pari sono rispecchiate.
.. _class_CanvasItem_constant_TEXTURE_REPEAT_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`TextureRepeat<enum_CanvasItem_TextureRepeat>` **TEXTURE_REPEAT_MAX** = ``4``
Rappresenta la dimensione dell'enumerazione :ref:`TextureRepeat<enum_CanvasItem_TextureRepeat>`.
.. rst-class:: classref-item-separator
----
.. _enum_CanvasItem_ClipChildrenMode:
.. rst-class:: classref-enumeration
enum **ClipChildrenMode**: :ref:`🔗<enum_CanvasItem_ClipChildrenMode>`
.. _class_CanvasItem_constant_CLIP_CHILDREN_DISABLED:
.. rst-class:: classref-enumeration-constant
:ref:`ClipChildrenMode<enum_CanvasItem_ClipChildrenMode>` **CLIP_CHILDREN_DISABLED** = ``0``
I figli sono disegnati su questo nodo e non sono ritagliati.
.. _class_CanvasItem_constant_CLIP_CHILDREN_ONLY:
.. rst-class:: classref-enumeration-constant
:ref:`ClipChildrenMode<enum_CanvasItem_ClipChildrenMode>` **CLIP_CHILDREN_ONLY** = ``1``
Questo nodo è utilizzato come maschera e **non** è disegnato. La maschera si basa sul canale alfa di questo nodo: i pixel opachi sono mantenuti, i pixel trasparenti sono scartati e i pixel semitrasparenti sono sfumati in base alla loro opacità. I figli sono ritagliati nell'area disegnata di questo nodo.
.. _class_CanvasItem_constant_CLIP_CHILDREN_AND_DRAW:
.. rst-class:: classref-enumeration-constant
:ref:`ClipChildrenMode<enum_CanvasItem_ClipChildrenMode>` **CLIP_CHILDREN_AND_DRAW** = ``2``
Questo nodo è utilizzato come maschera ed è anche disegnato. La maschera si basa sul canale alfa di questo nodo: i pixel opachi sono mantenuti, i pixel trasparenti sono scartati e i pixel semitrasparenti sono sfumati in base alla loro opacità. I figli sono ritagliati nell'area disegnata di questo nodo.
.. _class_CanvasItem_constant_CLIP_CHILDREN_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`ClipChildrenMode<enum_CanvasItem_ClipChildrenMode>` **CLIP_CHILDREN_MAX** = ``3``
Rappresenta la dimensione dell'enumerazione :ref:`ClipChildrenMode<enum_CanvasItem_ClipChildrenMode>`.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Costanti
----------------
.. _class_CanvasItem_constant_NOTIFICATION_TRANSFORM_CHANGED:
.. rst-class:: classref-constant
**NOTIFICATION_TRANSFORM_CHANGED** = ``2000`` :ref:`🔗<class_CanvasItem_constant_NOTIFICATION_TRANSFORM_CHANGED>`
Notifica ricevuta quando la trasformazione globale di questo nodo cambia, se :ref:`is_transform_notification_enabled()<class_CanvasItem_method_is_transform_notification_enabled>` è ``true``. Vedi anche :ref:`set_notify_transform()<class_CanvasItem_method_set_notify_transform>` e :ref:`get_transform()<class_CanvasItem_method_get_transform>`.
\ **Nota:** Molti elementi canvas come :ref:`Camera2D<class_Camera2D>` o :ref:`CollisionObject2D<class_CollisionObject2D>` abilitano questa automaticamente per funzionare correttamente.
.. _class_CanvasItem_constant_NOTIFICATION_LOCAL_TRANSFORM_CHANGED:
.. rst-class:: classref-constant
**NOTIFICATION_LOCAL_TRANSFORM_CHANGED** = ``35`` :ref:`🔗<class_CanvasItem_constant_NOTIFICATION_LOCAL_TRANSFORM_CHANGED>`
Notifica ricevuta quando la trasformazione di questo nodo cambia, se :ref:`is_local_transform_notification_enabled()<class_CanvasItem_method_is_local_transform_notification_enabled>` è ``true``. Questa notifica non viene ricevuta quando la trasformazione di un nodo :ref:`Node2D<class_Node2D>` genitore cambia. Vedi anche :ref:`set_notify_local_transform()<class_CanvasItem_method_set_notify_local_transform>`.
\ **Nota:** Molti elementi canvas come :ref:`Camera2D<class_Camera2D>` o :ref:`CollisionObject2D<class_CollisionObject2D>` abilitano questa automaticamente per funzionare correttamente.
.. _class_CanvasItem_constant_NOTIFICATION_DRAW:
.. rst-class:: classref-constant
**NOTIFICATION_DRAW** = ``30`` :ref:`🔗<class_CanvasItem_constant_NOTIFICATION_DRAW>`
Viene richiesto di disegnare il **CanvasItem** (vedi :ref:`_draw()<class_CanvasItem_private_method__draw>`).
.. _class_CanvasItem_constant_NOTIFICATION_VISIBILITY_CHANGED:
.. rst-class:: classref-constant
**NOTIFICATION_VISIBILITY_CHANGED** = ``31`` :ref:`🔗<class_CanvasItem_constant_NOTIFICATION_VISIBILITY_CHANGED>`
Notifica ricevuta quando la visibilità di questo nodo cambia (vedi :ref:`visible<class_CanvasItem_property_visible>` e :ref:`is_visible_in_tree()<class_CanvasItem_method_is_visible_in_tree>`).
Questa notifica viene ricevuta *prima* del segnale corrispondente :ref:`visibility_changed<class_CanvasItem_signal_visibility_changed>`.
.. _class_CanvasItem_constant_NOTIFICATION_ENTER_CANVAS:
.. rst-class:: classref-constant
**NOTIFICATION_ENTER_CANVAS** = ``32`` :ref:`🔗<class_CanvasItem_constant_NOTIFICATION_ENTER_CANVAS>`
Il **CanvasItem** è entrato nel canvas.
.. _class_CanvasItem_constant_NOTIFICATION_EXIT_CANVAS:
.. rst-class:: classref-constant
**NOTIFICATION_EXIT_CANVAS** = ``33`` :ref:`🔗<class_CanvasItem_constant_NOTIFICATION_EXIT_CANVAS>`
The **CanvasItem** has exited the canvas.
This notification is sent in reversed order.
.. _class_CanvasItem_constant_NOTIFICATION_WORLD_2D_CHANGED:
.. rst-class:: classref-constant
**NOTIFICATION_WORLD_2D_CHANGED** = ``36`` :ref:`🔗<class_CanvasItem_constant_NOTIFICATION_WORLD_2D_CHANGED>`
Notifica ricevuta quando questo **CanvasItem** è registrato in un nuovo :ref:`World2D<class_World2D>` (vedi :ref:`get_world_2d()<class_CanvasItem_method_get_world_2d>`).
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descrizioni delle proprietà
------------------------------------------------------
.. _class_CanvasItem_property_clip_children:
.. rst-class:: classref-property
:ref:`ClipChildrenMode<enum_CanvasItem_ClipChildrenMode>` **clip_children** = ``0`` :ref:`🔗<class_CanvasItem_property_clip_children>`
.. rst-class:: classref-property-setget
- |void| **set_clip_children_mode**\ (\ value\: :ref:`ClipChildrenMode<enum_CanvasItem_ClipChildrenMode>`\ )
- :ref:`ClipChildrenMode<enum_CanvasItem_ClipChildrenMode>` **get_clip_children_mode**\ (\ )
La modalità con cui questo nodo ritaglia i suoi figli, fungendo da maschera.
\ **Nota:** Non è possibile annidare o inserire i nodi ritagliati in un :ref:`CanvasGroup<class_CanvasGroup>`. Se un antenato di questo nodo ritaglia i suoi figli o è un :ref:`CanvasGroup<class_CanvasGroup>`, è necessario impostare la modalità di ritaglio di questo nodo su :ref:`CLIP_CHILDREN_DISABLED<class_CanvasItem_constant_CLIP_CHILDREN_DISABLED>` per evitare comportamenti imprevisti.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_property_light_mask:
.. rst-class:: classref-property
:ref:`int<class_int>` **light_mask** = ``1`` :ref:`🔗<class_CanvasItem_property_light_mask>`
.. rst-class:: classref-property-setget
- |void| **set_light_mask**\ (\ value\: :ref:`int<class_int>`\ )
- :ref:`int<class_int>` **get_light_mask**\ (\ )
Gli strati di rendering in cui questo **CanvasItem** risponde ai nodi :ref:`Light2D<class_Light2D>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_property_material:
.. rst-class:: classref-property
:ref:`Material<class_Material>` **material** :ref:`🔗<class_CanvasItem_property_material>`
.. rst-class:: classref-property-setget
- |void| **set_material**\ (\ value\: :ref:`Material<class_Material>`\ )
- :ref:`Material<class_Material>` **get_material**\ (\ )
Il materiale applicato a questo **CanvasItem**.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_property_modulate:
.. rst-class:: classref-property
:ref:`Color<class_Color>` **modulate** = ``Color(1, 1, 1, 1)`` :ref:`🔗<class_CanvasItem_property_modulate>`
.. rst-class:: classref-property-setget
- |void| **set_modulate**\ (\ value\: :ref:`Color<class_Color>`\ )
- :ref:`Color<class_Color>` **get_modulate**\ (\ )
Il colore applicato a questo **CanvasItem**. Questa proprietà influisce sui **CanvasItem** figli, a differenza di :ref:`self_modulate<class_CanvasItem_property_self_modulate>` che influisce solo sul nodo stesso.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_property_self_modulate:
.. rst-class:: classref-property
:ref:`Color<class_Color>` **self_modulate** = ``Color(1, 1, 1, 1)`` :ref:`🔗<class_CanvasItem_property_self_modulate>`
.. rst-class:: classref-property-setget
- |void| **set_self_modulate**\ (\ value\: :ref:`Color<class_Color>`\ )
- :ref:`Color<class_Color>` **get_self_modulate**\ (\ )
Il colore applicato a questo **CanvasItem**. Questa proprietà **non** influisce sui **CanvasItem** figli, a differenza di :ref:`modulate<class_CanvasItem_property_modulate>` che influisce sia sul nodo stesso sia sui suoi figli.
\ **Nota:** Anche i figli interni non sono influenzati da questa proprietà (vedi il parametro ``include_internal`` in :ref:`Node.get_child()<class_Node_method_get_child>`). Per i nodi integrati, ciò include gli slider in :ref:`ColorPicker<class_ColorPicker>` e la barra delle schede in :ref:`TabContainer<class_TabContainer>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_property_show_behind_parent:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **show_behind_parent** = ``false`` :ref:`🔗<class_CanvasItem_property_show_behind_parent>`
.. rst-class:: classref-property-setget
- |void| **set_draw_behind_parent**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_draw_behind_parent_enabled**\ (\ )
Se ``true``, questo nodo si disegna dietro il suo genitore.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_property_texture_filter:
.. rst-class:: classref-property
:ref:`TextureFilter<enum_CanvasItem_TextureFilter>` **texture_filter** = ``0`` :ref:`🔗<class_CanvasItem_property_texture_filter>`
.. rst-class:: classref-property-setget
- |void| **set_texture_filter**\ (\ value\: :ref:`TextureFilter<enum_CanvasItem_TextureFilter>`\ )
- :ref:`TextureFilter<enum_CanvasItem_TextureFilter>` **get_texture_filter**\ (\ )
La modalità di filtro usata per renderizzare le texture di questo **CanvasItem**.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_property_texture_repeat:
.. rst-class:: classref-property
:ref:`TextureRepeat<enum_CanvasItem_TextureRepeat>` **texture_repeat** = ``0`` :ref:`🔗<class_CanvasItem_property_texture_repeat>`
.. rst-class:: classref-property-setget
- |void| **set_texture_repeat**\ (\ value\: :ref:`TextureRepeat<enum_CanvasItem_TextureRepeat>`\ )
- :ref:`TextureRepeat<enum_CanvasItem_TextureRepeat>` **get_texture_repeat**\ (\ )
La modalità di ripetizione utilizzata per renderizzare le texture di questo **CanvasItem**. Influisce su ciò che accade quando la texture è campionata al di fuori dei suoi limiti, ad esempio impostando un :ref:`Sprite2D.region_rect<class_Sprite2D_property_region_rect>` più grande della texture o assegnando punti UV di un :ref:`Polygon2D<class_Polygon2D>` al di fuori della texture.
\ **Nota:** :ref:`TextureRect<class_TextureRect>` non è influenzato da :ref:`texture_repeat<class_CanvasItem_property_texture_repeat>`, poiché utilizza una propria implementazione per ripetere le texture.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_property_top_level:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **top_level** = ``false`` :ref:`🔗<class_CanvasItem_property_top_level>`
.. rst-class:: classref-property-setget
- |void| **set_as_top_level**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_set_as_top_level**\ (\ )
Se ``true``, questo **CanvasItem** *non* erediterà la sua trasformazione dai **CanvasItem** genitori. Anche il suo ordine di disegno sarà modificato per disegnarlo sopra altri **CanvasItem** che non hanno :ref:`top_level<class_CanvasItem_property_top_level>` impostato su ``true``. Il **CanvasItem** si comporterà effettivamente come se fosse un figlio di un semplice :ref:`Node<class_Node>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_property_use_parent_material:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **use_parent_material** = ``false`` :ref:`🔗<class_CanvasItem_property_use_parent_material>`
.. rst-class:: classref-property-setget
- |void| **set_use_parent_material**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **get_use_parent_material**\ (\ )
Se ``true``, il :ref:`material<class_CanvasItem_property_material>` del **CanvasItem** genitore è utilizzato come materiale di questo nodo.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_property_visibility_layer:
.. rst-class:: classref-property
:ref:`int<class_int>` **visibility_layer** = ``1`` :ref:`🔗<class_CanvasItem_property_visibility_layer>`
.. rst-class:: classref-property-setget
- |void| **set_visibility_layer**\ (\ value\: :ref:`int<class_int>`\ )
- :ref:`int<class_int>` **get_visibility_layer**\ (\ )
The rendering layer in which this **CanvasItem** is rendered by :ref:`Viewport<class_Viewport>` nodes. A :ref:`Viewport<class_Viewport>` will render a **CanvasItem** if it and all its parents share a layer with the :ref:`Viewport<class_Viewport>`'s canvas cull mask.
\ **Note:** A **CanvasItem** does not inherit its parents' visibility layers. This means that if a parent **CanvasItem** does not have all the same layers as its child, the child may not be visible even if both the parent and child have :ref:`visible<class_CanvasItem_property_visible>` set to ``true``. For example, if a parent has layer 1 and a child has layer 2, the child will not be visible in a :ref:`Viewport<class_Viewport>` with the canvas cull mask set to layer 1 or 2 (see :ref:`Viewport.canvas_cull_mask<class_Viewport_property_canvas_cull_mask>`). To ensure that both the parent and child are visible, the parent must have both layers 1 and 2, or the child must have :ref:`top_level<class_CanvasItem_property_top_level>` set to ``true``.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_property_visible:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **visible** = ``true`` :ref:`🔗<class_CanvasItem_property_visible>`
.. rst-class:: classref-property-setget
- |void| **set_visible**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_visible**\ (\ )
Se ``true``, questo **CanvasItem** potrebbe essere disegnato. Se questo **CanvasItem** sia effettivamente disegnato dipende dalla visibilità di tutti i suoi **CanvasItem** antenati. In altre parole: questo **CanvasItem** sarà disegnato quando :ref:`is_visible_in_tree()<class_CanvasItem_method_is_visible_in_tree>` restituisce ``true`` e tutti i **CanvasItem** antenati condividono almeno uno strato di visibilità (:ref:`visibility_layer<class_CanvasItem_property_visibility_layer>`) con questo **CanvasItem**.
\ **Nota:** Per i controlli che ereditano :ref:`Popup<class_Popup>`, il modo corretto per renderli visibili è di invece chiamare una delle molteplici funzioni ``popup*()``.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_property_y_sort_enabled:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **y_sort_enabled** = ``false`` :ref:`🔗<class_CanvasItem_property_y_sort_enabled>`
.. rst-class:: classref-property-setget
- |void| **set_y_sort_enabled**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_y_sort_enabled**\ (\ )
Se ``true``, questo e i nodi **CanvasItem** figli con una posizione in Y più alta sono renderizzati davanti ai nodi con una posizione in Y più bassa. Se ``false``, questo nodo e i **CanvasItem** figli sono renderizzati normalmente nell'ordine dell'albero di scene.
Con l'ordinamento in Y abilitato su un nodo genitore ('A') ma disabilitato su un nodo figlio ('B'), il nodo figlio ('B') è ordinato ma i suoi figli ('C1', 'C2', ecc.) renderizzano insieme sulla stessa posizione in Y del nodo figlio ("B"). Ciò consente di organizzare l'ordine di rendering di una scena senza modificare l'albero di scene.
I nodi sono ordinati l'uno rispetto all'altro solo se si trovano sullo stesso :ref:`z_index<class_CanvasItem_property_z_index>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_property_z_as_relative:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **z_as_relative** = ``true`` :ref:`🔗<class_CanvasItem_property_z_as_relative>`
.. rst-class:: classref-property-setget
- |void| **set_z_as_relative**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_z_relative**\ (\ )
Se ``true``, l'indice Z effettivo di questo nodo è relativo all'indice Z del suo genitore.
Ad esempio, se :ref:`z_index<class_CanvasItem_property_z_index>` è ``2`` e l'indice Z effettivo del suo genitore è ``3``, allora l'indice Z effettivo di questo nodo sarà ``5`` (``2 + 3``).
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_property_z_index:
.. rst-class:: classref-property
:ref:`int<class_int>` **z_index** = ``0`` :ref:`🔗<class_CanvasItem_property_z_index>`
.. rst-class:: classref-property-setget
- |void| **set_z_index**\ (\ value\: :ref:`int<class_int>`\ )
- :ref:`int<class_int>` **get_z_index**\ (\ )
Controlla l'ordine in cui sono disegnati i nodi. Un nodo con un indice Z più alto sarà visualizzato davanti agli altri. Deve essere compreso tra :ref:`RenderingServer.CANVAS_ITEM_Z_MIN<class_RenderingServer_constant_CANVAS_ITEM_Z_MIN>` e :ref:`RenderingServer.CANVAS_ITEM_Z_MAX<class_RenderingServer_constant_CANVAS_ITEM_Z_MAX>` (inclusi).
\ **Nota:** L'indice Z **non** influisce sull'ordine in cui sono elaborati i nodi **CanvasItem** o sul modo in cui sono gestiti gli eventi di input. Questo è particolarmente importante da tenere in mente per i nodi :ref:`Control<class_Control>`.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descrizioni dei metodi
--------------------------------------------
.. _class_CanvasItem_private_method__draw:
.. rst-class:: classref-method
|void| **_draw**\ (\ ) |virtual| :ref:`🔗<class_CanvasItem_private_method__draw>`
Chiamato quando questo **CanvasItem** è stato richiesto di ridisegnare (dopo che è stato chiamato il metodo :ref:`queue_redraw()<class_CanvasItem_method_queue_redraw>`, manualmente o dal motore).
Corrisponde alla notifica :ref:`NOTIFICATION_DRAW<class_CanvasItem_constant_NOTIFICATION_DRAW>` in :ref:`Object._notification()<class_Object_private_method__notification>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_animation_slice:
.. rst-class:: classref-method
|void| **draw_animation_slice**\ (\ animation_length\: :ref:`float<class_float>`, slice_begin\: :ref:`float<class_float>`, slice_end\: :ref:`float<class_float>`, offset\: :ref:`float<class_float>` = 0.0\ ) :ref:`🔗<class_CanvasItem_method_draw_animation_slice>`
I comandi di disegno successivi verranno ignorati a meno che non rientrino nella sezione di animazione specificata. Questo è un modo più rapido per implementare animazioni che si ripetono sullo sfondo anziché ridisegnarle costantemente.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_arc:
.. rst-class:: classref-method
|void| **draw_arc**\ (\ center\: :ref:`Vector2<class_Vector2>`, radius\: :ref:`float<class_float>`, start_angle\: :ref:`float<class_float>`, end_angle\: :ref:`float<class_float>`, point_count\: :ref:`int<class_int>`, color\: :ref:`Color<class_Color>`, width\: :ref:`float<class_float>` = -1.0, antialiased\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_CanvasItem_method_draw_arc>`
Draws an unfilled arc between the given angles with a uniform ``color`` and ``width`` and optional antialiasing (supported only for positive ``width``). The larger the value of ``point_count``, the smoother the curve. ``center`` is defined in local space. For elliptical arcs, see :ref:`draw_ellipse_arc()<class_CanvasItem_method_draw_ellipse_arc>`. See also :ref:`draw_circle()<class_CanvasItem_method_draw_circle>`.
If ``width`` is negative, it will be ignored and the arc will be drawn using :ref:`RenderingServer.PRIMITIVE_LINE_STRIP<class_RenderingServer_constant_PRIMITIVE_LINE_STRIP>`. This means that when the CanvasItem is scaled, the arc will remain thin. If this behavior is not desired, then pass a positive ``width`` like ``1.0``.
The arc is drawn from ``start_angle`` towards the value of ``end_angle`` so in clockwise direction if ``start_angle < end_angle`` and counter-clockwise otherwise. Passing the same angles but in reversed order will produce the same arc. If absolute difference of ``start_angle`` and ``end_angle`` is greater than :ref:`@GDScript.TAU<class_@GDScript_constant_TAU>` radians, then a full circle arc is drawn (i.e. arc will not overlap itself).
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_char:
.. rst-class:: classref-method
|void| **draw_char**\ (\ font\: :ref:`Font<class_Font>`, pos\: :ref:`Vector2<class_Vector2>`, char\: :ref:`String<class_String>`, font_size\: :ref:`int<class_int>` = 16, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1), oversampling\: :ref:`float<class_float>` = 0.0\ ) |const| :ref:`🔗<class_CanvasItem_method_draw_char>`
Disegna il primo carattere di una stringa usando un font personalizzato. Se ``oversampling`` è maggiore di zero, è utilizzato come fattore di sovracampionamento del font, altrimenti sono utilizzate le impostazioni di sovracampionamento della viewport. ``pos`` è definito in spazio locale.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_char_outline:
.. rst-class:: classref-method
|void| **draw_char_outline**\ (\ font\: :ref:`Font<class_Font>`, pos\: :ref:`Vector2<class_Vector2>`, char\: :ref:`String<class_String>`, font_size\: :ref:`int<class_int>` = 16, size\: :ref:`int<class_int>` = -1, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1), oversampling\: :ref:`float<class_float>` = 0.0\ ) |const| :ref:`🔗<class_CanvasItem_method_draw_char_outline>`
Disegna il contorno del primo carattere di una stringa usando un font personalizzato. Se ``oversampling`` è maggiore di zero, è utilizzato come fattore di sovracampionamento del font, altrimenti sono utilizzate le impostazioni di sovracampionamento della viewport. ``pos`` è definito in spazio locale.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_circle:
.. rst-class:: classref-method
|void| **draw_circle**\ (\ position\: :ref:`Vector2<class_Vector2>`, radius\: :ref:`float<class_float>`, color\: :ref:`Color<class_Color>`, filled\: :ref:`bool<class_bool>` = true, width\: :ref:`float<class_float>` = -1.0, antialiased\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_CanvasItem_method_draw_circle>`
Draws a circle, with ``position`` defined in local space. See also :ref:`draw_ellipse()<class_CanvasItem_method_draw_ellipse>`, :ref:`draw_arc()<class_CanvasItem_method_draw_arc>`, :ref:`draw_polyline()<class_CanvasItem_method_draw_polyline>`, and :ref:`draw_polygon()<class_CanvasItem_method_draw_polygon>`.
If ``filled`` is ``true``, the circle will be filled with the ``color`` specified. If ``filled`` is ``false``, the circle will be drawn as a stroke with the ``color`` and ``width`` specified.
If ``width`` is negative, then two-point primitives will be drawn instead of a four-point ones. This means that when the CanvasItem is scaled, the lines will remain thin. If this behavior is not desired, then pass a positive ``width`` like ``1.0``.
If ``antialiased`` is ``true``, half transparent "feathers" will be attached to the boundary, making outlines smooth.
\ **Note:** ``width`` is only effective if ``filled`` is ``false``.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_colored_polygon:
.. rst-class:: classref-method
|void| **draw_colored_polygon**\ (\ points\: :ref:`PackedVector2Array<class_PackedVector2Array>`, color\: :ref:`Color<class_Color>`, uvs\: :ref:`PackedVector2Array<class_PackedVector2Array>` = PackedVector2Array(), texture\: :ref:`Texture2D<class_Texture2D>` = null\ ) :ref:`🔗<class_CanvasItem_method_draw_colored_polygon>`
Disegna un poligono colorato con un numero qualsiasi di punti, convesso o concavo. I punti nell'array ``points`` sono definiti in spazio locale. A differenza di :ref:`draw_polygon()<class_CanvasItem_method_draw_polygon>`, è necessario specificare un singolo colore per l'intero poligono.
\ **Nota:** Se spesso viene ridisegnato lo stesso poligono con un numero elevato di vertici, considera di precalcolare la triangolazione con :ref:`Geometry2D.triangulate_polygon()<class_Geometry2D_method_triangulate_polygon>` e di usare :ref:`draw_mesh()<class_CanvasItem_method_draw_mesh>`, :ref:`draw_multimesh()<class_CanvasItem_method_draw_multimesh>` o :ref:`RenderingServer.canvas_item_add_triangle_array()<class_RenderingServer_method_canvas_item_add_triangle_array>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_dashed_line:
.. rst-class:: classref-method
|void| **draw_dashed_line**\ (\ from\: :ref:`Vector2<class_Vector2>`, to\: :ref:`Vector2<class_Vector2>`, color\: :ref:`Color<class_Color>`, width\: :ref:`float<class_float>` = -1.0, dash\: :ref:`float<class_float>` = 2.0, aligned\: :ref:`bool<class_bool>` = true, antialiased\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_CanvasItem_method_draw_dashed_line>`
Disegna una linea tratteggiata da un punto 2D a un altro, con un colore e uno spessore specificati. Le posizioni ``from`` e ``to`` sono definite in spazio locale. Vedi anche :ref:`draw_line()<class_CanvasItem_method_draw_line>`, :ref:`draw_multiline()<class_CanvasItem_method_draw_multiline>` e :ref:`draw_polyline()<class_CanvasItem_method_draw_polyline>`.
Se ``width`` è negativo, verrà disegnata una primitiva a due punti invece di una a quattro punti. Ciò significa che quando il CanvasItem viene ridimensionato, le parti della linea rimarranno sottile. Se questo comportamento non è desiderato, passare un valore positivo per ``width`` come ``1.0``.
\ ``dash`` è la lunghezza di ogni trattino in pixel, con lo spazio tra ogni trattino della stessa lunghezza. Se ``aligned`` è ``true``, la lunghezza del primo e dell'ultimo trattino potrebbe essere accorciata o allungata per consentire alla linea di iniziare e finire nei punti precisi definiti da ``from`` e ``to``. Entrambe le estremità sono sempre simmetriche quando ``aligned`` è ``true``. Se ``aligned`` è ``false``, tutti i trattini avranno la stessa lunghezza, ma la linea potrebbe apparire incompleta alla fine, a causa dei trattini che non si dividono equamente per la lunghezza della linea. Quando ``aligned`` è ``false``, vengono disegnati solo trattini completi.
Se ``antialiased`` è ``true``, al contorno verranno aggiunte delle "sfumature" semitrasparenti, rendendo i contorni più lisci.
\ **Nota:** ``antialiased`` è efficace solo se ``width`` è maggiore di ``0.0``.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_ellipse:
.. rst-class:: classref-method
|void| **draw_ellipse**\ (\ position\: :ref:`Vector2<class_Vector2>`, major\: :ref:`float<class_float>`, minor\: :ref:`float<class_float>`, color\: :ref:`Color<class_Color>`, filled\: :ref:`bool<class_bool>` = true, width\: :ref:`float<class_float>` = -1.0, antialiased\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_CanvasItem_method_draw_ellipse>`
Draws an ellipse with semi-major axis ``major`` and semi-minor axis ``minor``. See also :ref:`draw_circle()<class_CanvasItem_method_draw_circle>`, :ref:`draw_ellipse_arc()<class_CanvasItem_method_draw_ellipse_arc>`, :ref:`draw_polyline()<class_CanvasItem_method_draw_polyline>`, and :ref:`draw_polygon()<class_CanvasItem_method_draw_polygon>`.
If ``filled`` is ``true``, the ellipse will be filled with the ``color`` specified. If ``filled`` is ``false``, the ellipse will be drawn as a stroke with the ``color`` and ``width`` specified.
If ``width`` is negative, then two-point primitives will be drawn instead of four-point ones. This means that when the CanvasItem is scaled, the lines will remain thin. If this behavior is not desired, then pass a positive ``width`` like ``1.0``.
If ``antialiased`` is ``true``, half transparent "feathers" will be attached to the boundary, making outlines smooth.
\ **Note:** ``width`` is only effective if ``filled`` is ``false``.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_ellipse_arc:
.. rst-class:: classref-method
|void| **draw_ellipse_arc**\ (\ center\: :ref:`Vector2<class_Vector2>`, major\: :ref:`float<class_float>`, minor\: :ref:`float<class_float>`, start_angle\: :ref:`float<class_float>`, end_angle\: :ref:`float<class_float>`, point_count\: :ref:`int<class_int>`, color\: :ref:`Color<class_Color>`, width\: :ref:`float<class_float>` = -1.0, antialiased\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_CanvasItem_method_draw_ellipse_arc>`
Draws an unfilled elliptical arc between the given angles with a uniform ``color`` and ``width`` and optional antialiasing (supported only for positive ``width``). The larger the value of ``point_count``, the smoother the curve. For circular arcs, see :ref:`draw_arc()<class_CanvasItem_method_draw_arc>`. See also :ref:`draw_ellipse()<class_CanvasItem_method_draw_ellipse>`.
If ``width`` is negative, it will be ignored and the arc will be drawn using :ref:`RenderingServer.PRIMITIVE_LINE_STRIP<class_RenderingServer_constant_PRIMITIVE_LINE_STRIP>`. This means that when the CanvasItem is scaled, the arc will remain thin. If this behavior is not desired, then pass a positive ``width`` like ``1.0``.
The arc is drawn from ``start_angle`` towards the value of ``end_angle`` so in clockwise direction if ``start_angle < end_angle`` and counter-clockwise otherwise. Passing the same angles but in reversed order will produce the same arc. If absolute difference of ``start_angle`` and ``end_angle`` is greater than :ref:`@GDScript.TAU<class_@GDScript_constant_TAU>` radians, then a full ellipse is drawn (i.e. arc will not overlap itself).
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_end_animation:
.. rst-class:: classref-method
|void| **draw_end_animation**\ (\ ) :ref:`🔗<class_CanvasItem_method_draw_end_animation>`
Dopo aver inviato tutte le sezioni di animazione tramite :ref:`draw_animation_slice()<class_CanvasItem_method_draw_animation_slice>`, è possibile utilizzare questa funzione per ripristinare il passaggio di disegno allo stato predefinito (tutti i comandi di disegno successivi saranno visibili). Se questo caso d'uso specifico non è desiderato, non è necessario utilizzare questa funzione dopo aver inviato le sezioni.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_lcd_texture_rect_region:
.. rst-class:: classref-method
|void| **draw_lcd_texture_rect_region**\ (\ texture\: :ref:`Texture2D<class_Texture2D>`, rect\: :ref:`Rect2<class_Rect2>`, src_rect\: :ref:`Rect2<class_Rect2>`, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1)\ ) :ref:`🔗<class_CanvasItem_method_draw_lcd_texture_rect_region>`
Disegna una regione rettangolare texturizzata della texture del font con anti-aliasing dei subpixel LCD in una posizione specifica, opzionalmente modulata da un colore. Il rettangolo ``rect`` è definito in spazio locale.
La texture viene disegnata attraverso la seguente operazione di fusione, ignorando la modalità di fusione del :ref:`CanvasItemMaterial<class_CanvasItemMaterial>`:
::
dst.r = texture.r * modulate.r * modulate.a + dst.r * (1.0 - texture.r * modulate.a);
dst.g = texture.g * modulate.g * modulate.a + dst.g * (1.0 - texture.g * modulate.a);
dst.b = texture.b * modulate.b * modulate.a + dst.b * (1.0 - texture.b * modulate.a);
dst.a = modulate.a + dst.a * (1.0 - modulate.a);
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_line:
.. rst-class:: classref-method
|void| **draw_line**\ (\ from\: :ref:`Vector2<class_Vector2>`, to\: :ref:`Vector2<class_Vector2>`, color\: :ref:`Color<class_Color>`, width\: :ref:`float<class_float>` = -1.0, antialiased\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_CanvasItem_method_draw_line>`
Disegna una linea da un punto 2D a un altro, con il colore e la larghezza specificati. È possibile opzionalmente applicare un antialiasing. Le posizioni ``from`` e ``to`` sono definite in spazio locale. Vedi anche :ref:`draw_dashed_line()<class_CanvasItem_method_draw_dashed_line>`, :ref:`draw_multiline()<class_CanvasItem_method_draw_multiline>` e :ref:`draw_polyline()<class_CanvasItem_method_draw_polyline>`.
Se ``width`` è negativo, verrà disegnata una primitiva a due punti invece di una a quattro punti. Ciò significa che quando il CanvasItem viene ridimensionato, la linea rimarrà sottile. Se questo comportamento non è desiderato, passare un valore positivo per ``width`` come ``1.0``.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_mesh:
.. rst-class:: classref-method
|void| **draw_mesh**\ (\ mesh\: :ref:`Mesh<class_Mesh>`, texture\: :ref:`Texture2D<class_Texture2D>`, transform\: :ref:`Transform2D<class_Transform2D>` = Transform2D(1, 0, 0, 1, 0, 0), modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1)\ ) :ref:`🔗<class_CanvasItem_method_draw_mesh>`
Disegna una :ref:`Mesh<class_Mesh>` in 2D, utilizzando la texture fornita. Vedi :ref:`MeshInstance2D<class_MeshInstance2D>` per la documentazione al riguardo. La trasformazione ``transform`` è definita in spazio locale.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_msdf_texture_rect_region:
.. rst-class:: classref-method
|void| **draw_msdf_texture_rect_region**\ (\ texture\: :ref:`Texture2D<class_Texture2D>`, rect\: :ref:`Rect2<class_Rect2>`, src_rect\: :ref:`Rect2<class_Rect2>`, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1), outline\: :ref:`float<class_float>` = 0.0, pixel_range\: :ref:`float<class_float>` = 4.0, scale\: :ref:`float<class_float>` = 1.0\ ) :ref:`🔗<class_CanvasItem_method_draw_msdf_texture_rect_region>`
Disegna una regione rettangolare con texture della texture MSDF in una posizione specificata, modulata facoltativamente da un colore. Il rettangolo ``rect`` è definito in spazio locale. Vedi :ref:`FontFile.multichannel_signed_distance_field<class_FontFile_property_multichannel_signed_distance_field>` per ulteriori informazioni e avvertimenti sul rendering dei font MSDF.
Se ``outline`` è positivo, ogni valore del canale alfa del pixel nella regione viene impostato sul valore massimo della distanza reale nel raggio ``outline``.
Il valore di ``pixel_range`` dovrebbe essere lo stesso usato durante la generazione della texture MSDF.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_multiline:
.. rst-class:: classref-method
|void| **draw_multiline**\ (\ points\: :ref:`PackedVector2Array<class_PackedVector2Array>`, color\: :ref:`Color<class_Color>`, width\: :ref:`float<class_float>` = -1.0, antialiased\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_CanvasItem_method_draw_multiline>`
Disegna più linee sconnesse con uno spessore (``width``) e un colore (``color``) uniformi. Ogni linea è definita da due punti consecutivi nell'array ``points`` in spazio locale, ovvero l'i-esimo segmento è costituito da ``points[2 * i]``, ``points[2 * i + 1]`` estremi. Quando si disegnano grandi quantità di linee, questa funzione è più veloce rispetto all'utilizzo di singole chiamate al metodo :ref:`draw_line()<class_CanvasItem_method_draw_line>`. Per disegnare linee interconnesse, usare invece il metodo :ref:`draw_polyline()<class_CanvasItem_method_draw_polyline>`.
Se ``width`` è negativo, verrà disegnata una primitiva a due punti invece di una a quattro punti. Ciò significa che quando il CanvasItem viene ridimensionato, la linea rimarrà sottile. Se questo comportamento non è desiderato, passare un valore positivo per ``width`` come ``1.0``.
\ **Nota:** ``antialiased`` è efficace solo se ``width`` è maggiore di ``0.0``.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_multiline_colors:
.. rst-class:: classref-method
|void| **draw_multiline_colors**\ (\ points\: :ref:`PackedVector2Array<class_PackedVector2Array>`, colors\: :ref:`PackedColorArray<class_PackedColorArray>`, width\: :ref:`float<class_float>` = -1.0, antialiased\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_CanvasItem_method_draw_multiline_colors>`
Disegna più linee sconnesse con uno spessore (``width``) uniforme e colore segmento-per-segmento . Ogni linea è definita da due punti consecutivi nell'array ``points`` in spazio locale, ovvero l'i-esimo segmento è costituito da ``points[2 * i]``, ``points[2 * i + 1]`` estremi e ha il colore ``colors[i]``. Quando si disegnano grandi quantità di linee, questa funzione è più veloce rispetto all'utilizzo di singole chiamate al metodo :ref:`draw_line()<class_CanvasItem_method_draw_line>`. Per disegnare linee interconnesse, usare invece il metodo :ref:`draw_polyline_colors()<class_CanvasItem_method_draw_polyline_colors>`.
Se ``width`` è negativo, verrà disegnata una primitiva a due punti invece di una a quattro punti. Ciò significa che quando il CanvasItem viene ridimensionato, la linea rimarrà sottile. Se questo comportamento non è desiderato, passare un valore positivo per ``width`` come ``1.0``.
\ **Nota:** ``antialiased`` è efficace solo se ``width`` è maggiore di ``0.0``.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_multiline_string:
.. rst-class:: classref-method
|void| **draw_multiline_string**\ (\ font\: :ref:`Font<class_Font>`, pos\: :ref:`Vector2<class_Vector2>`, text\: :ref:`String<class_String>`, alignment\: :ref:`HorizontalAlignment<enum_@GlobalScope_HorizontalAlignment>` = 0, width\: :ref:`float<class_float>` = -1, font_size\: :ref:`int<class_int>` = 16, max_lines\: :ref:`int<class_int>` = -1, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1), brk_flags\: |bitfield|\[:ref:`LineBreakFlag<enum_TextServer_LineBreakFlag>`\] = 3, justification_flags\: |bitfield|\[:ref:`JustificationFlag<enum_TextServer_JustificationFlag>`\] = 3, direction\: :ref:`Direction<enum_TextServer_Direction>` = 0, orientation\: :ref:`Orientation<enum_TextServer_Orientation>` = 0, oversampling\: :ref:`float<class_float>` = 0.0\ ) |const| :ref:`🔗<class_CanvasItem_method_draw_multiline_string>`
Divide il testo ``text`` in righe e lo disegna attraverso il ``font`` specificato nella posizione ``pos`` in spazio locale (angolo in alto a sinistra). Il colore del testo verrà moltiplicato per ``modulate``. Se ``width`` è maggiore o uguale a 0, il testo verrà troncato se supera la larghezza specificata. Se ``oversampling`` è maggiore di zero, è utilizzato come fattore di sovracampionamento del font, altrimenti sono utilizzate le impostazioni di sovracampionamento della viewport.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_multiline_string_outline:
.. rst-class:: classref-method
|void| **draw_multiline_string_outline**\ (\ font\: :ref:`Font<class_Font>`, pos\: :ref:`Vector2<class_Vector2>`, text\: :ref:`String<class_String>`, alignment\: :ref:`HorizontalAlignment<enum_@GlobalScope_HorizontalAlignment>` = 0, width\: :ref:`float<class_float>` = -1, font_size\: :ref:`int<class_int>` = 16, max_lines\: :ref:`int<class_int>` = -1, size\: :ref:`int<class_int>` = 1, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1), brk_flags\: |bitfield|\[:ref:`LineBreakFlag<enum_TextServer_LineBreakFlag>`\] = 3, justification_flags\: |bitfield|\[:ref:`JustificationFlag<enum_TextServer_JustificationFlag>`\] = 3, direction\: :ref:`Direction<enum_TextServer_Direction>` = 0, orientation\: :ref:`Orientation<enum_TextServer_Orientation>` = 0, oversampling\: :ref:`float<class_float>` = 0.0\ ) |const| :ref:`🔗<class_CanvasItem_method_draw_multiline_string_outline>`
Divide il testo ``text`` in righe e ne disegna il contorno attraverso il ``font`` specificato nella posizione ``pos`` in spazio locale (angolo in alto a sinistra). Il colore del testo verrà moltiplicato per ``modulate``. Se ``width`` è maggiore o uguale a 0, il testo verrà troncato se supera la larghezza specificata. Se ``oversampling`` è maggiore di zero, è utilizzato come fattore di sovracampionamento del font, altrimenti sono utilizzate le impostazioni di sovracampionamento della viewport.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_multimesh:
.. rst-class:: classref-method
|void| **draw_multimesh**\ (\ multimesh\: :ref:`MultiMesh<class_MultiMesh>`, texture\: :ref:`Texture2D<class_Texture2D>`\ ) :ref:`🔗<class_CanvasItem_method_draw_multimesh>`
Disegna una :ref:`MultiMesh<class_MultiMesh>` in 2D, utilizzando la texture fornita. Vedi :ref:`MultiMeshInstance2D<class_MultiMeshInstance2D>` per la documentazione al riguardo.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_polygon:
.. rst-class:: classref-method
|void| **draw_polygon**\ (\ points\: :ref:`PackedVector2Array<class_PackedVector2Array>`, colors\: :ref:`PackedColorArray<class_PackedColorArray>`, uvs\: :ref:`PackedVector2Array<class_PackedVector2Array>` = PackedVector2Array(), texture\: :ref:`Texture2D<class_Texture2D>` = null\ ) :ref:`🔗<class_CanvasItem_method_draw_polygon>`
Disegna un poligono solido con un numero qualsiasi di punti, convessi o concavi. A differenza di :ref:`draw_colored_polygon()<class_CanvasItem_method_draw_colored_polygon>`, è possibile modificare il colore di ogni punto individualmente. L'array ``points`` è definito in spazio locale. Vedi anche :ref:`draw_polyline()<class_CanvasItem_method_draw_polyline>` e :ref:`draw_polyline_colors()<class_CanvasItem_method_draw_polyline_colors>`. Se c'è bisogno di maggiore flessibilità (ad esempio, per poter utilizzare ossa), usa invece :ref:`RenderingServer.canvas_item_add_triangle_array()<class_RenderingServer_method_canvas_item_add_triangle_array>`.
\ **Nota:** Se spesso viene ridisegnato lo stesso poligono con un numero elevato di vertici, considera di precalcolare la triangolazione con :ref:`Geometry2D.triangulate_polygon()<class_Geometry2D_method_triangulate_polygon>` e di usare :ref:`draw_mesh()<class_CanvasItem_method_draw_mesh>`, :ref:`draw_multimesh()<class_CanvasItem_method_draw_multimesh>` o :ref:`RenderingServer.canvas_item_add_triangle_array()<class_RenderingServer_method_canvas_item_add_triangle_array>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_polyline:
.. rst-class:: classref-method
|void| **draw_polyline**\ (\ points\: :ref:`PackedVector2Array<class_PackedVector2Array>`, color\: :ref:`Color<class_Color>`, width\: :ref:`float<class_float>` = -1.0, antialiased\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_CanvasItem_method_draw_polyline>`
Disegna segmenti interconnessi di linea con un colore (``color``) e uno spessore (``width``) uniformi e antialiasing opzionale (supportato solo per valori positivi di ``width``). L'array ``points`` è definito in spazio locale. Quando si disegnano grandi quantità di linee, questo metodo è più veloce rispetto all'utilizzo di singole chiamate al metodo :ref:`draw_line()<class_CanvasItem_method_draw_line>`. Per disegnare linee scollegate, usare invece il metodo :ref:`draw_multiline()<class_CanvasItem_method_draw_multiline>`. Vedi anche :ref:`draw_polygon()<class_CanvasItem_method_draw_polygon>`.
Se ``width`` è negativo, verrà ignorato e la polilinea verrà disegnata utilizzando :ref:`RenderingServer.PRIMITIVE_LINE_STRIP<class_RenderingServer_constant_PRIMITIVE_LINE_STRIP>`. Ciò significa che quando CanvasItem viene ridimensionato, la polilinea rimarrà sottile. Se questo comportamento non è desiderato, passare un valore positivo per ``width`` come ``1.0``.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_polyline_colors:
.. rst-class:: classref-method
|void| **draw_polyline_colors**\ (\ points\: :ref:`PackedVector2Array<class_PackedVector2Array>`, colors\: :ref:`PackedColorArray<class_PackedColorArray>`, width\: :ref:`float<class_float>` = -1.0, antialiased\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_CanvasItem_method_draw_polyline_colors>`
Disegna segmenti di linea interconnessi con uno spessore (``width``) uniforme, colorazione punto per punto e antialiasing opzionale (supportato solo per valori positivi di ``width``). I colori assegnati ai punti della linea corrispondono per indici tra ``points`` e ``colors``, ovvero ogni segmento della linea è riempito con un gradiente tra i colori delle estremità. L'array ``points`` è definito in spazio locale. Quando si disegnano grandi quantità di linee, questo metodo è più veloce rispetto all'utilizzo di singole chiamate al metodo :ref:`draw_line()<class_CanvasItem_method_draw_line>`. Per disegnare linee scollegate, usare invece :ref:`draw_multiline_colors()<class_CanvasItem_method_draw_multiline_colors>`. Vedi anche :ref:`draw_polygon()<class_CanvasItem_method_draw_polygon>`.
Se ``width`` è negativo, verrà ignorato e la polilinea verrà disegnata utilizzando :ref:`RenderingServer.PRIMITIVE_LINE_STRIP<class_RenderingServer_constant_PRIMITIVE_LINE_STRIP>`. Ciò significa che quando CanvasItem viene ridimensionato, la polilinea rimarrà sottile. Se questo comportamento non è desiderato, passare un valore positivo per ``width`` come ``1.0``.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_primitive:
.. rst-class:: classref-method
|void| **draw_primitive**\ (\ points\: :ref:`PackedVector2Array<class_PackedVector2Array>`, colors\: :ref:`PackedColorArray<class_PackedColorArray>`, uvs\: :ref:`PackedVector2Array<class_PackedVector2Array>`, texture\: :ref:`Texture2D<class_Texture2D>` = null\ ) :ref:`🔗<class_CanvasItem_method_draw_primitive>`
Disegna una primitiva personalizzata. 1 punto per un punto, 2 punti per una linea, 3 punti per un triangolo e 4 punti per un quadrato. Se vengono specificati 0 punti o più di 4 punti, nulla verrà disegnato e verrà stampato un messaggio di errore. L'array ``points`` è definito in spazio locale. Vedi anche :ref:`draw_line()<class_CanvasItem_method_draw_line>`, :ref:`draw_polyline()<class_CanvasItem_method_draw_polyline>`, :ref:`draw_polygon()<class_CanvasItem_method_draw_polygon>` e :ref:`draw_rect()<class_CanvasItem_method_draw_rect>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_rect:
.. rst-class:: classref-method
|void| **draw_rect**\ (\ rect\: :ref:`Rect2<class_Rect2>`, color\: :ref:`Color<class_Color>`, filled\: :ref:`bool<class_bool>` = true, width\: :ref:`float<class_float>` = -1.0, antialiased\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_CanvasItem_method_draw_rect>`
Disegna un rettangolo. Se ``filled`` è ``true``, il rettangolo verrà riempito con il colore ``color``. Se ``filled`` è ``false``, il rettangolo verrà disegnato come un tratto con il colore ``color`` e lo spessore ``width``. Il rettangolo ``rect`` è specificato in spazio locale. Vedi anche :ref:`draw_texture_rect()<class_CanvasItem_method_draw_texture_rect>`.
Se ``width`` è negativo, verranno disegnate primitive a due punti invece che a quattro. Ciò significa che quando il CanvasItem viene ridimensionato, le linee rimarranno sottili. Se questo comportamento non è desiderato, passare un valore positivo per ``width`` come ``1.0``.
Se ``antialiased`` è ``true``, al contorno verranno aggiunte delle "sfumature" semitrasparenti, rendendo i contorni più lisci.
\ **Nota:** ``width`` è efficace solo se ``filled`` è ``false``.
\ **Nota:** I rettangoli vuoti disegnati con un ``width`` negativo potrebbero non essere visualizzati perfettamente. Ad esempio, gli angoli potrebbero mancare o essere più chiari a causa di linee sovrapposte (per un ``color`` traslucido).
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_set_transform:
.. rst-class:: classref-method
|void| **draw_set_transform**\ (\ position\: :ref:`Vector2<class_Vector2>`, rotation\: :ref:`float<class_float>` = 0.0, scale\: :ref:`Vector2<class_Vector2>` = Vector2(1, 1)\ ) :ref:`🔗<class_CanvasItem_method_draw_set_transform>`
Imposta una trasformazione locale personalizzata per disegnare tramite componenti. Tutto ciò che sarà disegnato in seguito sarà trasformato da questa trasformazione.
\ **Nota:** :ref:`FontFile.oversampling<class_FontFile_property_oversampling>` *non* tiene conto di ``scale``. Ciò significa che aumentando o diminuendo la scala i font bitmap e i font dinamici rasterizzati (non MSDF) risulteranno sfocati o pixelati. Per garantire che il testo rimanga nitido a prescindere dalla scala, è possibile abilitare il rendering dei font MSDF abilitando :ref:`ProjectSettings.gui/theme/default_font_multichannel_signed_distance_field<class_ProjectSettings_property_gui/theme/default_font_multichannel_signed_distance_field>` (si applica solo al font predefinito del progetto) o abilitando **Multichannel Signed Distance Field** nelle opzioni di importazione di un DynamicFont per i font personalizzati. Sui font di sistema, è possibile abilitare :ref:`SystemFont.multichannel_signed_distance_field<class_SystemFont_property_multichannel_signed_distance_field>` nell'ispettore.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_set_transform_matrix:
.. rst-class:: classref-method
|void| **draw_set_transform_matrix**\ (\ xform\: :ref:`Transform2D<class_Transform2D>`\ ) :ref:`🔗<class_CanvasItem_method_draw_set_transform_matrix>`
Imposta una trasformazione locale personalizzata per il passaggio di disegno, tramite matrice. Tutto ciò che sarà disegnato in seguito sarà trasformato da questa trasformazione.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_string:
.. rst-class:: classref-method
|void| **draw_string**\ (\ font\: :ref:`Font<class_Font>`, pos\: :ref:`Vector2<class_Vector2>`, text\: :ref:`String<class_String>`, alignment\: :ref:`HorizontalAlignment<enum_@GlobalScope_HorizontalAlignment>` = 0, width\: :ref:`float<class_float>` = -1, font_size\: :ref:`int<class_int>` = 16, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1), justification_flags\: |bitfield|\[:ref:`JustificationFlag<enum_TextServer_JustificationFlag>`\] = 3, direction\: :ref:`Direction<enum_TextServer_Direction>` = 0, orientation\: :ref:`Orientation<enum_TextServer_Orientation>` = 0, oversampling\: :ref:`float<class_float>` = 0.0\ ) |const| :ref:`🔗<class_CanvasItem_method_draw_string>`
Disegna il testo ``text`` attraverso il ``font`` specificato nella posizione ``pos`` in spazio locale (angolo in basso a sinistra, usando la linea di base del font). Il colore del testo verrà moltiplicato per ``modulate``. Se ``width`` è maggiore o uguale a 0, il testo verrà troncato se supera la larghezza specificata. Se ``oversampling`` è maggiore di zero, è utilizzato come fattore di sovracampionamento del font, altrimenti sono utilizzate le impostazioni di sovracampionamento della viewport.
\ **Esempio:** Disegna "Ciao mondo", usando il font predefinito del progetto:
.. tabs::
.. code-tab:: gdscript
# Se si utilizza questo metodo in uno script che viene ridisegnato costantemente,
# spostare la dichiarazione `default_font` in una variabile membro assegnata in `_ready()`
# in modo che il controllo venga creato una sola volta.
var default_font = ThemeDB.fallback_font
var default_font_size = ThemeDB.fallback_font_size
draw_string(default_font, Vector2(64, 64), "Ciao mondo", HORIZONTAL_ALIGNMENT_LEFT, -1, default_font_size)
.. code-tab:: csharp
// Se si utilizza questo metodo in uno script che viene ridisegnato costantemente,
// spostare la dichiarazione `default_font` in una variabile membro assegnata in `_ready()`
// in modo che il controllo venga creato una sola volta.
Font defaultFont = ThemeDB.FallbackFont;
int defaultFontSize = ThemeDB.FallbackFontSize;
DrawString(defaultFont, new Vector2(64, 64), "Ciao mondo", HORIZONTAL_ALIGNMENT_LEFT, -1, defaultFontSize);
Vedi anche :ref:`Font.draw_string()<class_Font_method_draw_string>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_string_outline:
.. rst-class:: classref-method
|void| **draw_string_outline**\ (\ font\: :ref:`Font<class_Font>`, pos\: :ref:`Vector2<class_Vector2>`, text\: :ref:`String<class_String>`, alignment\: :ref:`HorizontalAlignment<enum_@GlobalScope_HorizontalAlignment>` = 0, width\: :ref:`float<class_float>` = -1, font_size\: :ref:`int<class_int>` = 16, size\: :ref:`int<class_int>` = 1, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1), justification_flags\: |bitfield|\[:ref:`JustificationFlag<enum_TextServer_JustificationFlag>`\] = 3, direction\: :ref:`Direction<enum_TextServer_Direction>` = 0, orientation\: :ref:`Orientation<enum_TextServer_Orientation>` = 0, oversampling\: :ref:`float<class_float>` = 0.0\ ) |const| :ref:`🔗<class_CanvasItem_method_draw_string_outline>`
Disegna il contorno del testo ``text`` attraverso il ``font`` specificato nella posizione ``pos`` in spazio locale (angolo in basso a sinistra, usando la linea di base del font). Il colore del testo verrà moltiplicato per ``modulate``. Se ``width`` è maggiore o uguale a 0, il testo verrà troncato se supera la larghezza specificata. Se ``oversampling`` è maggiore di zero, è utilizzato come fattore di sovracampionamento del font, altrimenti sono utilizzate le impostazioni di sovracampionamento della viewport.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_style_box:
.. rst-class:: classref-method
|void| **draw_style_box**\ (\ style_box\: :ref:`StyleBox<class_StyleBox>`, rect\: :ref:`Rect2<class_Rect2>`\ ) :ref:`🔗<class_CanvasItem_method_draw_style_box>`
Disegna un rettangolo con stile. Il ``rect`` è definito nello spazio locale.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_texture:
.. rst-class:: classref-method
|void| **draw_texture**\ (\ texture\: :ref:`Texture2D<class_Texture2D>`, position\: :ref:`Vector2<class_Vector2>`, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1)\ ) :ref:`🔗<class_CanvasItem_method_draw_texture>`
Disegna una texture in una determinata posizione. La posizione ``position`` è definita in spazio locale.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_texture_rect:
.. rst-class:: classref-method
|void| **draw_texture_rect**\ (\ texture\: :ref:`Texture2D<class_Texture2D>`, rect\: :ref:`Rect2<class_Rect2>`, tile\: :ref:`bool<class_bool>`, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1), transpose\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_CanvasItem_method_draw_texture_rect>`
Disegna un rettangolo con texture in una determinata posizione, modulato facoltativamente da un colore. Il rettangolo ``rect`` è definito in spazio locale. Se ``transpose`` è ``true``, la texture avrà le sue coordinate X e Y scambiate. Vedi anche :ref:`draw_rect()<class_CanvasItem_method_draw_rect>` e :ref:`draw_texture_rect_region()<class_CanvasItem_method_draw_texture_rect_region>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_texture_rect_region:
.. rst-class:: classref-method
|void| **draw_texture_rect_region**\ (\ texture\: :ref:`Texture2D<class_Texture2D>`, rect\: :ref:`Rect2<class_Rect2>`, src_rect\: :ref:`Rect2<class_Rect2>`, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1), transpose\: :ref:`bool<class_bool>` = false, clip_uv\: :ref:`bool<class_bool>` = true\ ) :ref:`🔗<class_CanvasItem_method_draw_texture_rect_region>`
Disegna un rettangolo con texture da una regione di texture (specificata da ``src_rect``) in una determinata posizione in spazio locale, modulato facoltativamente da un colore. Se ``transpose`` è ``true``, la texture avrà le sue coordinate X e Y scambiate. Vedi anche :ref:`draw_texture_rect()<class_CanvasItem_method_draw_texture_rect>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_force_update_transform:
.. rst-class:: classref-method
|void| **force_update_transform**\ (\ ) :ref:`🔗<class_CanvasItem_method_force_update_transform>`
Forza l'aggiornamento della trasformazione del nodo. Fallisce se il nodo non si trova all'interno dell'albero. Vedi anche :ref:`get_transform()<class_CanvasItem_method_get_transform>`\
\ **Nota:** Per motivi di prestazioni, le modifiche alle trasformazioni sono solitamente accumulate e applicate *una sola volta* alla fine del frame. L'aggiornamento si propaga anche attraverso i figli di **CanvasItem**. Pertanto, utilizzare questo metodo solo quando è necessaria una trasformazione aggiornata (ad esempio durante le operazioni di fisica).
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_get_canvas:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **get_canvas**\ (\ ) |const| :ref:`🔗<class_CanvasItem_method_get_canvas>`
Restituisce il :ref:`RID<class_RID>` del canvas :ref:`World2D<class_World2D>` in cui è registrato questo nodo, utilizzato dal :ref:`RenderingServer<class_RenderingServer>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_get_canvas_item:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **get_canvas_item**\ (\ ) |const| :ref:`🔗<class_CanvasItem_method_get_canvas_item>`
Restituisce il RID interno dell'elemento canvas utilizzato dal :ref:`RenderingServer<class_RenderingServer>` per questo nodo.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_get_canvas_layer_node:
.. rst-class:: classref-method
:ref:`CanvasLayer<class_CanvasLayer>` **get_canvas_layer_node**\ (\ ) |const| :ref:`🔗<class_CanvasItem_method_get_canvas_layer_node>`
Restituisce il :ref:`CanvasLayer<class_CanvasLayer>` che contiene questo nodo, o ``null`` se il nodo non è in alcun :ref:`CanvasLayer<class_CanvasLayer>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_get_canvas_transform:
.. rst-class:: classref-method
:ref:`Transform2D<class_Transform2D>` **get_canvas_transform**\ (\ ) |const| :ref:`🔗<class_CanvasItem_method_get_canvas_transform>`
Restituisce la trasformazione di questo nodo, convertita dal sistema di coordinate del suo canvas registrato al sistema di coordinate della sua viewport. Vedi anche :ref:`Node.get_viewport()<class_Node_method_get_viewport>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_get_global_mouse_position:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **get_global_mouse_position**\ (\ ) |const| :ref:`🔗<class_CanvasItem_method_get_global_mouse_position>`
Restituisce la globale posizione del cursore del mouse relativa al :ref:`CanvasLayer<class_CanvasLayer>` che contiene questo **CanvasItem**.
\ **Nota:** Per le coordinate nello spazio dello schermo (ad esempio quando si utilizza un :ref:`Popup<class_Popup>` non incorporato), è possibile usare :ref:`DisplayServer.mouse_get_position()<class_DisplayServer_method_mouse_get_position>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_get_global_transform:
.. rst-class:: classref-method
:ref:`Transform2D<class_Transform2D>` **get_global_transform**\ (\ ) |const| :ref:`🔗<class_CanvasItem_method_get_global_transform>`
Restituisce la matrice di trasformazione globale di questo elemento, ovvero la trasformazione combinata fino al nodo **CanvasItem** più in alto. L'elemento più in alto è un **CanvasItem** che non ha un genitore, ha un genitore che non è **CanvasItem** o ha il suo :ref:`top_level<class_CanvasItem_property_top_level>` abilitato.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_get_global_transform_with_canvas:
.. rst-class:: classref-method
:ref:`Transform2D<class_Transform2D>` **get_global_transform_with_canvas**\ (\ ) |const| :ref:`🔗<class_CanvasItem_method_get_global_transform_with_canvas>`
Restituisce la trasformazione dal sistema di coordinate locali di questo **CanvasItem** al sistema di coordinate del la :ref:`Viewport<class_Viewport>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_get_instance_shader_parameter:
.. rst-class:: classref-method
:ref:`Variant<class_Variant>` **get_instance_shader_parameter**\ (\ name\: :ref:`StringName<class_StringName>`\ ) |const| :ref:`🔗<class_CanvasItem_method_get_instance_shader_parameter>`
Ottieni il valore di un parametro dello shader impostato in questa istanza.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_get_local_mouse_position:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **get_local_mouse_position**\ (\ ) |const| :ref:`🔗<class_CanvasItem_method_get_local_mouse_position>`
Restituisce la posizione del mouse in questo **CanvasItem** utilizzando il sistema di coordinate locali di questo **CanvasItem**.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_get_screen_transform:
.. rst-class:: classref-method
:ref:`Transform2D<class_Transform2D>` **get_screen_transform**\ (\ ) |const| :ref:`🔗<class_CanvasItem_method_get_screen_transform>`
Returns the transform of this **CanvasItem** in global screen coordinates (i.e. taking window position into account). Mostly useful for editor plugins.
Equivalent to :ref:`get_global_transform_with_canvas()<class_CanvasItem_method_get_global_transform_with_canvas>` if the window is embedded (see :ref:`Viewport.gui_embed_subwindows<class_Viewport_property_gui_embed_subwindows>`).
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_get_transform:
.. rst-class:: classref-method
:ref:`Transform2D<class_Transform2D>` **get_transform**\ (\ ) |const| :ref:`🔗<class_CanvasItem_method_get_transform>`
Restituisce la matrice di trasformazione di questo **CanvasItem**.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_get_viewport_rect:
.. rst-class:: classref-method
:ref:`Rect2<class_Rect2>` **get_viewport_rect**\ (\ ) |const| :ref:`🔗<class_CanvasItem_method_get_viewport_rect>`
Restituisce i confini della viewport di questo nodo come :ref:`Rect2<class_Rect2>`. Vedi anche :ref:`Node.get_viewport()<class_Node_method_get_viewport>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_get_viewport_transform:
.. rst-class:: classref-method
:ref:`Transform2D<class_Transform2D>` **get_viewport_transform**\ (\ ) |const| :ref:`🔗<class_CanvasItem_method_get_viewport_transform>`
Restituisce la trasformazione di questo nodo, convertita dal sistema di coordinate del proprio canvas registrato al sistema di coordinate della viewport incorporatore. Vedi anche :ref:`Viewport.get_final_transform()<class_Viewport_method_get_final_transform>` e :ref:`Node.get_viewport()<class_Node_method_get_viewport>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_get_visibility_layer_bit:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **get_visibility_layer_bit**\ (\ layer\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_CanvasItem_method_get_visibility_layer_bit>`
Restituisce ``true`` se lo strato all'indice specificato è impostato in :ref:`visibility_layer<class_CanvasItem_property_visibility_layer>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_get_world_2d:
.. rst-class:: classref-method
:ref:`World2D<class_World2D>` **get_world_2d**\ (\ ) |const| :ref:`🔗<class_CanvasItem_method_get_world_2d>`
Restituisce il :ref:`World2D<class_World2D>` in cui è registrato questo nodo.
Di solito, questo è lo stesso utilizzato dalla viewport di questo nodo (vedi :ref:`Node.get_viewport()<class_Node_method_get_viewport>` e :ref:`Viewport.find_world_2d()<class_Viewport_method_find_world_2d>`).
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_hide:
.. rst-class:: classref-method
|void| **hide**\ (\ ) :ref:`🔗<class_CanvasItem_method_hide>`
Nasconde il **CanvasItem** se è attualmente visibile. Ciò equivale a impostare :ref:`visible<class_CanvasItem_property_visible>` su ``false``.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_is_local_transform_notification_enabled:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_local_transform_notification_enabled**\ (\ ) |const| :ref:`🔗<class_CanvasItem_method_is_local_transform_notification_enabled>`
Restituisce ``true`` se il nodo riceve :ref:`NOTIFICATION_LOCAL_TRANSFORM_CHANGED<class_CanvasItem_constant_NOTIFICATION_LOCAL_TRANSFORM_CHANGED>` quando cambia la sua trasformazione locale. Ciò è abilitato con :ref:`set_notify_local_transform()<class_CanvasItem_method_set_notify_local_transform>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_is_transform_notification_enabled:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_transform_notification_enabled**\ (\ ) |const| :ref:`🔗<class_CanvasItem_method_is_transform_notification_enabled>`
Restituisce ``true``, se il nodo riceve :ref:`NOTIFICATION_TRANSFORM_CHANGED<class_CanvasItem_constant_NOTIFICATION_TRANSFORM_CHANGED>` quando cambia la sua trasformazione globale. Ciò è abilitato con :ref:`set_notify_transform()<class_CanvasItem_method_set_notify_transform>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_is_visible_in_tree:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_visible_in_tree**\ (\ ) |const| :ref:`🔗<class_CanvasItem_method_is_visible_in_tree>`
Restituisce ``true`` se il nodo è presente in :ref:`SceneTree<class_SceneTree>`, la sua proprietà :ref:`visible<class_CanvasItem_property_visible>` è ``true`` e tutti i suoi antenati sono visibili. Se un antenato è nascosto, questo nodo non sarà visibile nell'albero di scene e quindi non verrà disegnato (vedi :ref:`_draw()<class_CanvasItem_private_method__draw>`).
La visibilità viene verificata solo nei nodi genitore che ereditano da **CanvasItem**, :ref:`CanvasLayer<class_CanvasLayer>` e :ref:`Window<class_Window>`. Se il genitore è di un altro tipo (ad esempio :ref:`Node<class_Node>`, :ref:`AnimationPlayer<class_AnimationPlayer>` o :ref:`Node3D<class_Node3D>`), è considerato visibile.
\ **Nota:** Questo metodo non tiene conto di :ref:`visibility_layer<class_CanvasItem_property_visibility_layer>`, quindi anche se restituisce ``true``, il nodo potrebbe non essere renderizzato.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_make_canvas_position_local:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **make_canvas_position_local**\ (\ viewport_point\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_CanvasItem_method_make_canvas_position_local>`
Trasforma ``viewport_point`` dalle coordinate della viewport alle coordinate locali di questo nodo.
Per l'operazione opposta, usa :ref:`get_global_transform_with_canvas()<class_CanvasItem_method_get_global_transform_with_canvas>`.
::
var viewport_point = get_global_transform_with_canvas() * local_point
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_make_input_local:
.. rst-class:: classref-method
:ref:`InputEvent<class_InputEvent>` **make_input_local**\ (\ event\: :ref:`InputEvent<class_InputEvent>`\ ) |const| :ref:`🔗<class_CanvasItem_method_make_input_local>`
Restituisce una copia dell'evento ``event`` con le sue coordinate convertite dallo spazio globale allo spazio locale di questo **CanvasItem**. Se non è possibile, restituisce lo stesso :ref:`InputEvent<class_InputEvent>` senza cambiamenti.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_move_to_front:
.. rst-class:: classref-method
|void| **move_to_front**\ (\ ) :ref:`🔗<class_CanvasItem_method_move_to_front>`
Sposta questo nodo sotto i suoi fratelli, solitamente garantendo che il nodo sia disegnato sopra i suoi fratelli. Non fa nulla se questo nodo non ha un genitore. Vedi anche :ref:`Node.move_child()<class_Node_method_move_child>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_queue_redraw:
.. rst-class:: classref-method
|void| **queue_redraw**\ (\ ) :ref:`🔗<class_CanvasItem_method_queue_redraw>`
Mette in coda il **CanvasItem** per ridisegnare. Durante il tempo di inattività, se **CanvasItem** è visibile, viene inviata :ref:`NOTIFICATION_DRAW<class_CanvasItem_constant_NOTIFICATION_DRAW>` e viene chiamato :ref:`_draw()<class_CanvasItem_private_method__draw>`. Ciò si verifica solo **una** volta per frame, anche se questo metodo è stato chiamato più volte.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_set_instance_shader_parameter:
.. rst-class:: classref-method
|void| **set_instance_shader_parameter**\ (\ name\: :ref:`StringName<class_StringName>`, value\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_CanvasItem_method_set_instance_shader_parameter>`
Imposta il valore di un'uniforme di shader solo per questa istanza (`uniforme per istanza <../tutorials/shaders/shader_reference/shading_language.html#per-instance-uniforms>`__). Consulta anche :ref:`ShaderMaterial.set_shader_parameter()<class_ShaderMaterial_method_set_shader_parameter>` per assegnare un'uniforme a tutte le istanze che utilizzano lo stesso :ref:`ShaderMaterial<class_ShaderMaterial>`.
\ **Nota:** Affinché un'uniforme di shader possa essere assegnabile per istanza individualmente, *deve* essere definita con ``instance uniform ...`` anziché ``uniform ...`` nel codice dello shader.
\ **Nota:** ``name`` è sensibile alle maiuscole e alle minuscole e deve corrispondere esattamente al nome dell'uniforme in codice (non al nome formattato nell'ispettore).
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_set_notify_local_transform:
.. rst-class:: classref-method
|void| **set_notify_local_transform**\ (\ enable\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_CanvasItem_method_set_notify_local_transform>`
Se ``true``, il nodo riceverà :ref:`NOTIFICATION_LOCAL_TRANSFORM_CHANGED<class_CanvasItem_constant_NOTIFICATION_LOCAL_TRANSFORM_CHANGED>` quando la sua trasformazione locale cambia.
\ **Nota:** Molti elementi canvas come :ref:`Bone2D<class_Bone2D>` o :ref:`CollisionShape2D<class_CollisionShape2D>` abilitano questo automaticamente per funzionare correttamente.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_set_notify_transform:
.. rst-class:: classref-method
|void| **set_notify_transform**\ (\ enable\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_CanvasItem_method_set_notify_transform>`
If ``true``, the node will receive :ref:`NOTIFICATION_TRANSFORM_CHANGED<class_CanvasItem_constant_NOTIFICATION_TRANSFORM_CHANGED>` whenever its global transform changes.
\ **Note:** Many canvas items such as :ref:`Camera2D<class_Camera2D>` or :ref:`Light2D<class_Light2D>` automatically enable this in order to function correctly.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_set_visibility_layer_bit:
.. rst-class:: classref-method
|void| **set_visibility_layer_bit**\ (\ layer\: :ref:`int<class_int>`, enabled\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_CanvasItem_method_set_visibility_layer_bit>`
Imposta/cancella singoli bit sugli strati di visibilità per il rendering. Ciò semplifica la modifica degli strati di visibilità di questo **CanvasItem**.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_show:
.. rst-class:: classref-method
|void| **show**\ (\ ) :ref:`🔗<class_CanvasItem_method_show>`
Mostra il **CanvasItem** se è attualmente nascosto. Ciò equivale a impostare :ref:`visible<class_CanvasItem_property_visible>` su ``true``.
\ **Note:** Per i controlli che ereditano :ref:`Popup<class_Popup>`, il modo corretto per renderli visibili è chiamare una delle molteplici funzioni ``popup*()``.
.. |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