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_viewport.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

2708 lines
167 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_Viewport:
Viewport
========
**Eredita:** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
**Ereditato da:** :ref:`SubViewport<class_SubViewport>`, :ref:`Window<class_Window>`
Classe di base astratta per viewport. Incapsula il disegno e l'interazione con un mondo di gioco.
.. rst-class:: classref-introduction-group
Descrizione
----------------------
Una **Viewport** crea una vista diversa sullo schermo, o una sotto-vista all'interno di un'altra viewport. I nodi 2D figlio saranno visualizzati su di essa, e anche i nodi Camera3D 3D figlio saranno renderizzati su di essa.
Facoltativamente, una viewport può avere il suo mondo 2D o 3D, quindi non condivide ciò che disegna con altre viewport.
Le viewport possono anche scegliere di essere ascoltatori audio, generando così audio posizionale a seconda di una telecamera figlio 2D o 3D.
Inoltre, le viewport possono essere assegnate a schermi diversi nel caso in cui i dispositivi abbiano più schermi.
Infine, le viewport possono anche comportarsi come destinazioni di rendering, nel qual caso non saranno visibili a meno che la texture associata non sia utilizzata per disegnare.
.. rst-class:: classref-introduction-group
Tutorial
----------------
- :doc:`Utilizzo dei Viewport <../tutorials/rendering/viewports>`
- :doc:`Viewport e trasformazioni di canvas <../tutorials/2d/2d_transforms>`
- `Demo di GUI in Viewport 3D <https://godotengine.org/asset-library/asset/2807>`__
- `Demo di viewport 3D in 2D <https://godotengine.org/asset-library/asset/2804>`__
- `Demo di viewport 2D in 3D <https://godotengine.org/asset-library/asset/2803>`__
- `Demo di cattura dello schermo <https://godotengine.org/asset-library/asset/2808>`__
- `Demo di schermo diviso dinamico <https://godotengine.org/asset-library/asset/2806>`__
- `Demo di scala della risoluzione 3D <https://godotengine.org/asset-library/asset/2805>`__
.. rst-class:: classref-reftable-group
Proprietà
------------------
.. table::
:widths: auto
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`AnisotropicFiltering<enum_Viewport_AnisotropicFiltering>` | :ref:`anisotropic_filtering_level<class_Viewport_property_anisotropic_filtering_level>` | ``2`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`audio_listener_enable_2d<class_Viewport_property_audio_listener_enable_2d>` | ``false`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`audio_listener_enable_3d<class_Viewport_property_audio_listener_enable_3d>` | ``false`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`canvas_cull_mask<class_Viewport_property_canvas_cull_mask>` | ``4294967295`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`DefaultCanvasItemTextureFilter<enum_Viewport_DefaultCanvasItemTextureFilter>` | :ref:`canvas_item_default_texture_filter<class_Viewport_property_canvas_item_default_texture_filter>` | ``1`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`DefaultCanvasItemTextureRepeat<enum_Viewport_DefaultCanvasItemTextureRepeat>` | :ref:`canvas_item_default_texture_repeat<class_Viewport_property_canvas_item_default_texture_repeat>` | ``0`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`Transform2D<class_Transform2D>` | :ref:`canvas_transform<class_Viewport_property_canvas_transform>` | |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`DebugDraw<enum_Viewport_DebugDraw>` | :ref:`debug_draw<class_Viewport_property_debug_draw>` | ``0`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`disable_3d<class_Viewport_property_disable_3d>` | ``false`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`fsr_sharpness<class_Viewport_property_fsr_sharpness>` | ``0.2`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`Transform2D<class_Transform2D>` | :ref:`global_canvas_transform<class_Viewport_property_global_canvas_transform>` | |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`gui_disable_input<class_Viewport_property_gui_disable_input>` | ``false`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`gui_drag_threshold<class_Viewport_property_gui_drag_threshold>` | ``10`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`gui_embed_subwindows<class_Viewport_property_gui_embed_subwindows>` | ``false`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`gui_snap_controls_to_pixels<class_Viewport_property_gui_snap_controls_to_pixels>` | ``true`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`handle_input_locally<class_Viewport_property_handle_input_locally>` | ``true`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`mesh_lod_threshold<class_Viewport_property_mesh_lod_threshold>` | ``1.0`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`MSAA<enum_Viewport_MSAA>` | :ref:`msaa_2d<class_Viewport_property_msaa_2d>` | ``0`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`MSAA<enum_Viewport_MSAA>` | :ref:`msaa_3d<class_Viewport_property_msaa_3d>` | ``0`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`oversampling<class_Viewport_property_oversampling>` | ``true`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`oversampling_override<class_Viewport_property_oversampling_override>` | ``0.0`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`own_world_3d<class_Viewport_property_own_world_3d>` | ``false`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`PhysicsInterpolationMode<enum_Node_PhysicsInterpolationMode>` | physics_interpolation_mode | ``1`` (overrides :ref:`Node<class_Node_property_physics_interpolation_mode>`) |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`physics_object_picking<class_Viewport_property_physics_object_picking>` | ``false`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`physics_object_picking_first_only<class_Viewport_property_physics_object_picking_first_only>` | ``false`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`physics_object_picking_sort<class_Viewport_property_physics_object_picking_sort>` | ``false`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`positional_shadow_atlas_16_bits<class_Viewport_property_positional_shadow_atlas_16_bits>` | ``true`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` | :ref:`positional_shadow_atlas_quad_0<class_Viewport_property_positional_shadow_atlas_quad_0>` | ``2`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` | :ref:`positional_shadow_atlas_quad_1<class_Viewport_property_positional_shadow_atlas_quad_1>` | ``2`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` | :ref:`positional_shadow_atlas_quad_2<class_Viewport_property_positional_shadow_atlas_quad_2>` | ``3`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` | :ref:`positional_shadow_atlas_quad_3<class_Viewport_property_positional_shadow_atlas_quad_3>` | ``4`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`positional_shadow_atlas_size<class_Viewport_property_positional_shadow_atlas_size>` | ``2048`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`Scaling3DMode<enum_Viewport_Scaling3DMode>` | :ref:`scaling_3d_mode<class_Viewport_property_scaling_3d_mode>` | ``0`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`scaling_3d_scale<class_Viewport_property_scaling_3d_scale>` | ``1.0`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`ScreenSpaceAA<enum_Viewport_ScreenSpaceAA>` | :ref:`screen_space_aa<class_Viewport_property_screen_space_aa>` | ``0`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`SDFOversize<enum_Viewport_SDFOversize>` | :ref:`sdf_oversize<class_Viewport_property_sdf_oversize>` | ``1`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`SDFScale<enum_Viewport_SDFScale>` | :ref:`sdf_scale<class_Viewport_property_sdf_scale>` | ``1`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`snap_2d_transforms_to_pixel<class_Viewport_property_snap_2d_transforms_to_pixel>` | ``false`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`snap_2d_vertices_to_pixel<class_Viewport_property_snap_2d_vertices_to_pixel>` | ``false`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`texture_mipmap_bias<class_Viewport_property_texture_mipmap_bias>` | ``0.0`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`transparent_bg<class_Viewport_property_transparent_bg>` | ``false`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`use_debanding<class_Viewport_property_use_debanding>` | ``false`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`use_hdr_2d<class_Viewport_property_use_hdr_2d>` | ``false`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`use_occlusion_culling<class_Viewport_property_use_occlusion_culling>` | ``false`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`use_taa<class_Viewport_property_use_taa>` | ``false`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`use_xr<class_Viewport_property_use_xr>` | ``false`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`VRSMode<enum_Viewport_VRSMode>` | :ref:`vrs_mode<class_Viewport_property_vrs_mode>` | ``0`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`Texture2D<class_Texture2D>` | :ref:`vrs_texture<class_Viewport_property_vrs_texture>` | |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`VRSUpdateMode<enum_Viewport_VRSUpdateMode>` | :ref:`vrs_update_mode<class_Viewport_property_vrs_update_mode>` | ``1`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`World2D<class_World2D>` | :ref:`world_2d<class_Viewport_property_world_2d>` | |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`World3D<class_World3D>` | :ref:`world_3d<class_Viewport_property_world_3d>` | |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
.. rst-class:: classref-reftable-group
Metodi
------------
.. table::
:widths: auto
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`World2D<class_World2D>` | :ref:`find_world_2d<class_Viewport_method_find_world_2d>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`World3D<class_World3D>` | :ref:`find_world_3d<class_Viewport_method_find_world_3d>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`AudioListener2D<class_AudioListener2D>` | :ref:`get_audio_listener_2d<class_Viewport_method_get_audio_listener_2d>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`AudioListener3D<class_AudioListener3D>` | :ref:`get_audio_listener_3d<class_Viewport_method_get_audio_listener_3d>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Camera2D<class_Camera2D>` | :ref:`get_camera_2d<class_Viewport_method_get_camera_2d>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Camera3D<class_Camera3D>` | :ref:`get_camera_3d<class_Viewport_method_get_camera_3d>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`get_canvas_cull_mask_bit<class_Viewport_method_get_canvas_cull_mask_bit>`\ (\ layer\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Array<class_Array>`\[:ref:`Window<class_Window>`\] | :ref:`get_embedded_subwindows<class_Viewport_method_get_embedded_subwindows>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Transform2D<class_Transform2D>` | :ref:`get_final_transform<class_Viewport_method_get_final_transform>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`get_mouse_position<class_Viewport_method_get_mouse_position>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`get_oversampling<class_Viewport_method_get_oversampling>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` | :ref:`get_positional_shadow_atlas_quadrant_subdiv<class_Viewport_method_get_positional_shadow_atlas_quadrant_subdiv>`\ (\ quadrant\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_render_info<class_Viewport_method_get_render_info>`\ (\ type\: :ref:`RenderInfoType<enum_Viewport_RenderInfoType>`, info\: :ref:`RenderInfo<enum_Viewport_RenderInfo>`\ ) |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Transform2D<class_Transform2D>` | :ref:`get_screen_transform<class_Viewport_method_get_screen_transform>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Transform2D<class_Transform2D>` | :ref:`get_stretch_transform<class_Viewport_method_get_stretch_transform>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`ViewportTexture<class_ViewportTexture>` | :ref:`get_texture<class_Viewport_method_get_texture>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`get_viewport_rid<class_Viewport_method_get_viewport_rid>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Rect2<class_Rect2>` | :ref:`get_visible_rect<class_Viewport_method_get_visible_rect>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`gui_cancel_drag<class_Viewport_method_gui_cancel_drag>`\ (\ ) |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Variant<class_Variant>` | :ref:`gui_get_drag_data<class_Viewport_method_gui_get_drag_data>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`gui_get_drag_description<class_Viewport_method_gui_get_drag_description>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Control<class_Control>` | :ref:`gui_get_focus_owner<class_Viewport_method_gui_get_focus_owner>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Control<class_Control>` | :ref:`gui_get_hovered_control<class_Viewport_method_gui_get_hovered_control>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`gui_is_drag_successful<class_Viewport_method_gui_is_drag_successful>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`gui_is_dragging<class_Viewport_method_gui_is_dragging>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`gui_release_focus<class_Viewport_method_gui_release_focus>`\ (\ ) |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`gui_set_drag_description<class_Viewport_method_gui_set_drag_description>`\ (\ description\: :ref:`String<class_String>`\ ) |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_input_handled<class_Viewport_method_is_input_handled>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`notify_mouse_entered<class_Viewport_method_notify_mouse_entered>`\ (\ ) |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`notify_mouse_exited<class_Viewport_method_notify_mouse_exited>`\ (\ ) |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`push_input<class_Viewport_method_push_input>`\ (\ event\: :ref:`InputEvent<class_InputEvent>`, in_local_coords\: :ref:`bool<class_bool>` = false\ ) |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`push_text_input<class_Viewport_method_push_text_input>`\ (\ text\: :ref:`String<class_String>`\ ) |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`push_unhandled_input<class_Viewport_method_push_unhandled_input>`\ (\ event\: :ref:`InputEvent<class_InputEvent>`, in_local_coords\: :ref:`bool<class_bool>` = false\ ) |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_canvas_cull_mask_bit<class_Viewport_method_set_canvas_cull_mask_bit>`\ (\ layer\: :ref:`int<class_int>`, enable\: :ref:`bool<class_bool>`\ ) |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_input_as_handled<class_Viewport_method_set_input_as_handled>`\ (\ ) |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_positional_shadow_atlas_quadrant_subdiv<class_Viewport_method_set_positional_shadow_atlas_quadrant_subdiv>`\ (\ quadrant\: :ref:`int<class_int>`, subdiv\: :ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>`\ ) |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`update_mouse_cursor_state<class_Viewport_method_update_mouse_cursor_state>`\ (\ ) |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`warp_mouse<class_Viewport_method_warp_mouse>`\ (\ position\: :ref:`Vector2<class_Vector2>`\ ) |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Segnali
--------------
.. _class_Viewport_signal_gui_focus_changed:
.. rst-class:: classref-signal
**gui_focus_changed**\ (\ node\: :ref:`Control<class_Control>`\ ) :ref:`🔗<class_Viewport_signal_gui_focus_changed>`
Emesso quando un nodo di controllo cattura il focus della tastiera.
\ **Nota:** Un nodo di controllo che perde il focus non provoca l'emissione di questo segnale.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_signal_size_changed:
.. rst-class:: classref-signal
**size_changed**\ (\ ) :ref:`🔗<class_Viewport_signal_size_changed>`
Emesso quando le dimensioni della viewport sono modificate, ridimensionandola o in altri modi.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Enumerazioni
------------------------
.. _enum_Viewport_PositionalShadowAtlasQuadrantSubdiv:
.. rst-class:: classref-enumeration
enum **PositionalShadowAtlasQuadrantSubdiv**: :ref:`🔗<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>`
.. _class_Viewport_constant_SHADOW_ATLAS_QUADRANT_SUBDIV_DISABLED:
.. rst-class:: classref-enumeration-constant
:ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **SHADOW_ATLAS_QUADRANT_SUBDIV_DISABLED** = ``0``
Questo quadrante non sarà utilizzato.
.. _class_Viewport_constant_SHADOW_ATLAS_QUADRANT_SUBDIV_1:
.. rst-class:: classref-enumeration-constant
:ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **SHADOW_ATLAS_QUADRANT_SUBDIV_1** = ``1``
Questo quadrante sarà utilizzato solo da una mappa di ombre.
.. _class_Viewport_constant_SHADOW_ATLAS_QUADRANT_SUBDIV_4:
.. rst-class:: classref-enumeration-constant
:ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **SHADOW_ATLAS_QUADRANT_SUBDIV_4** = ``2``
Questo quadrante sarà diviso in 4, e utilizzato da un massimo di 4 mappe di ombre.
.. _class_Viewport_constant_SHADOW_ATLAS_QUADRANT_SUBDIV_16:
.. rst-class:: classref-enumeration-constant
:ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **SHADOW_ATLAS_QUADRANT_SUBDIV_16** = ``3``
Questo quadrante sarà diviso in 16, e utilizzato da un massimo di 16 mappe di ombre.
.. _class_Viewport_constant_SHADOW_ATLAS_QUADRANT_SUBDIV_64:
.. rst-class:: classref-enumeration-constant
:ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **SHADOW_ATLAS_QUADRANT_SUBDIV_64** = ``4``
Questo quadrante sarà diviso in 64, e utilizzato da un massimo di 64 mappe di ombre.
.. _class_Viewport_constant_SHADOW_ATLAS_QUADRANT_SUBDIV_256:
.. rst-class:: classref-enumeration-constant
:ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **SHADOW_ATLAS_QUADRANT_SUBDIV_256** = ``5``
Questo quadrante sarà diviso in 256, e utilizzato da un massimo di 256 mappe di ombre. A meno che il valore di :ref:`positional_shadow_atlas_size<class_Viewport_property_positional_shadow_atlas_size>` non sia molto alto, le ombre in questo quadrante avranno una risoluzione molto bassa.
.. _class_Viewport_constant_SHADOW_ATLAS_QUADRANT_SUBDIV_1024:
.. rst-class:: classref-enumeration-constant
:ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **SHADOW_ATLAS_QUADRANT_SUBDIV_1024** = ``6``
Questo quadrante sarà diviso in 1024, e utilizzato da un massimo di 1024 mappe di ombre. A meno che il valore di :ref:`positional_shadow_atlas_size<class_Viewport_property_positional_shadow_atlas_size>` non sia molto alto, le ombre in questo quadrante avranno una risoluzione molto bassa.
.. _class_Viewport_constant_SHADOW_ATLAS_QUADRANT_SUBDIV_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **SHADOW_ATLAS_QUADRANT_SUBDIV_MAX** = ``7``
Rappresenta la dimensione dell'enumerazione :ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>`.
.. rst-class:: classref-item-separator
----
.. _enum_Viewport_Scaling3DMode:
.. rst-class:: classref-enumeration
enum **Scaling3DMode**: :ref:`🔗<enum_Viewport_Scaling3DMode>`
.. _class_Viewport_constant_SCALING_3D_MODE_BILINEAR:
.. rst-class:: classref-enumeration-constant
:ref:`Scaling3DMode<enum_Viewport_Scaling3DMode>` **SCALING_3D_MODE_BILINEAR** = ``0``
Utilizza il ridimensionamento bilineare per il buffer 3D della viewport. La quantità di ridimensionamento può essere impostata tramite :ref:`scaling_3d_scale<class_Viewport_property_scaling_3d_scale>`. Valori inferiori a ``1.0`` risulteranno in un sottocampionamento mentre valori superiori a ``1.0`` risulteranno in un sovracampionamento. Un valore di ``1.0`` disabilita il ridimensionamento.
.. _class_Viewport_constant_SCALING_3D_MODE_FSR:
.. rst-class:: classref-enumeration-constant
:ref:`Scaling3DMode<enum_Viewport_Scaling3DMode>` **SCALING_3D_MODE_FSR** = ``1``
Utilizza l'upscaling AMD FidelityFX Super Resolution 1.0 per il buffer 3D della viewport. La quantità di ridimensionamento può essere impostata tramite :ref:`scaling_3d_scale<class_Viewport_property_scaling_3d_scale>`. I valori inferiori a ``1.0`` risulteranno in un upscaling della viewport tramite FSR. I valori superiori a ``1.0`` non sono supportati e sarà invece utilizzato il downsampling bilineare. Un valore di ``1.0`` disabilita il ridimensionamento.
.. _class_Viewport_constant_SCALING_3D_MODE_FSR2:
.. rst-class:: classref-enumeration-constant
:ref:`Scaling3DMode<enum_Viewport_Scaling3DMode>` **SCALING_3D_MODE_FSR2** = ``2``
Utilizza l'upscaling AMD FidelityFX Super Resolution 2.2 per il buffer 3D della viewport. La quantità di ridimensionamento può essere impostata tramite :ref:`scaling_3d_scale<class_Viewport_property_scaling_3d_scale>`. I valori inferiori a ``1.0`` risulteranno nell'upscaling della viewport tramite FSR2. I valori superiori a ``1.0`` non sono supportati e sarà invece utilizzato il sottocampionamento bilineare. Un valore di ``1.0`` userà FSR2 alla risoluzione nativa come soluzione TAA.
.. _class_Viewport_constant_SCALING_3D_MODE_METALFX_SPATIAL:
.. rst-class:: classref-enumeration-constant
:ref:`Scaling3DMode<enum_Viewport_Scaling3DMode>` **SCALING_3D_MODE_METALFX_SPATIAL** = ``3``
Utilizza il `MetalFX spatial upscaler <https://developer.apple.com/documentation/metalfx/mtlfxspatialscaler#overview>`__ per il buffer 3D della viewport.
La quantità di ridimensionamento può essere impostata tramite :ref:`scaling_3d_scale<class_Viewport_property_scaling_3d_scale>`.
I valori inferiori a ``1.0`` risulteranno in un upscaling della viewport tramite MetalFX. I valori superiori a ``1.0`` non sono supportati e sarà invece utilizzato il downsampling bilineare. Un valore di ``1.0`` disabilita il ridimensionamento.
Ulteriori information: `MetalFX <https://developer.apple.com/documentation/metalfx>`__.
\ **Nota:** Supportato solo quando è in uso il driver di rendering Metal, il che limita questa modalità di ridimensionamento a macOS e iOS.
.. _class_Viewport_constant_SCALING_3D_MODE_METALFX_TEMPORAL:
.. rst-class:: classref-enumeration-constant
:ref:`Scaling3DMode<enum_Viewport_Scaling3DMode>` **SCALING_3D_MODE_METALFX_TEMPORAL** = ``4``
Utilizza il `l'upscaler temporale MetalFX <https://developer.apple.com/documentation/metalfx/mtlfxtemporalscaler#overview>`__ per il buffer 3D della viewport.
La quantità di ridimensionamento può essere impostata tramite :ref:`scaling_3d_scale<class_Viewport_property_scaling_3d_scale>`. Per determinare la scala minima di input, usa il metodo :ref:`RenderingDevice.limit_get()<class_RenderingDevice_method_limit_get>` con :ref:`RenderingDevice.LIMIT_METALFX_TEMPORAL_SCALER_MIN_SCALE<class_RenderingDevice_constant_LIMIT_METALFX_TEMPORAL_SCALER_MIN_SCALE>`.
I valori inferiori a ``1.0`` risulteranno in un upscaling della viewport tramite MetalFX. I valori superiori a ``1.0`` non sono supportati e sarà invece utilizzato il sottocampionamento bilineare. Un valore di ``1.0`` utilizzerà MetalFX a risoluzione nativa come soluzione TAA.
Ulteriori informazioni: `MetalFX <https://developer.apple.com/documentation/metalfx>`__.
\ **Nota:** Supportato solo quando è in uso il driver di rendering Metal, il che limita questa modalità di ridimensionamento a macOS e iOS.
.. _class_Viewport_constant_SCALING_3D_MODE_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`Scaling3DMode<enum_Viewport_Scaling3DMode>` **SCALING_3D_MODE_MAX** = ``5``
Rappresenta la dimensione dell'enumerazione :ref:`Scaling3DMode<enum_Viewport_Scaling3DMode>`.
.. rst-class:: classref-item-separator
----
.. _enum_Viewport_MSAA:
.. rst-class:: classref-enumeration
enum **MSAA**: :ref:`🔗<enum_Viewport_MSAA>`
.. _class_Viewport_constant_MSAA_DISABLED:
.. rst-class:: classref-enumeration-constant
:ref:`MSAA<enum_Viewport_MSAA>` **MSAA_DISABLED** = ``0``
Modalità antialiasing multicampione disattivata. Questo è il valore predefinito, ed è anche l'impostazione più veloce.
.. _class_Viewport_constant_MSAA_2X:
.. rst-class:: classref-enumeration-constant
:ref:`MSAA<enum_Viewport_MSAA>` **MSAA_2X** = ``1``
Usa un 2× Multisample Antialiasing. Ha un costo di prestazioni moderato. Aiuta a ridurre notevolmente l'aliasing, ma 4× MSAA risulta comunque sostanzialmente migliore.
.. _class_Viewport_constant_MSAA_4X:
.. rst-class:: classref-enumeration-constant
:ref:`MSAA<enum_Viewport_MSAA>` **MSAA_4X** = ``2``
Usa 4× Multisample Antialiasing. Questo ha un costo di prestazioni significativo, ed è generalmente un buon compromesso tra prestazioni e qualità.
.. _class_Viewport_constant_MSAA_8X:
.. rst-class:: classref-enumeration-constant
:ref:`MSAA<enum_Viewport_MSAA>` **MSAA_8X** = ``3``
Usa 8× Multisample Antialiasing. Ha un costo di prestazioni molto elevato. La differenza tra 4× e 8× MSAA potrebbe non essere sempre visibile in condizioni di gioco reali. Probabilmente non supportato su hardware di fascia bassa e più vecchio.
.. _class_Viewport_constant_MSAA_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`MSAA<enum_Viewport_MSAA>` **MSAA_MAX** = ``4``
Rappresenta la dimensione dell'enumerazione :ref:`MSAA<enum_Viewport_MSAA>`.
.. rst-class:: classref-item-separator
----
.. _enum_Viewport_AnisotropicFiltering:
.. rst-class:: classref-enumeration
enum **AnisotropicFiltering**: :ref:`🔗<enum_Viewport_AnisotropicFiltering>`
.. _class_Viewport_constant_ANISOTROPY_DISABLED:
.. rst-class:: classref-enumeration-constant
:ref:`AnisotropicFiltering<enum_Viewport_AnisotropicFiltering>` **ANISOTROPY_DISABLED** = ``0``
Il filtro anisotropico è disabilitato.
.. _class_Viewport_constant_ANISOTROPY_2X:
.. rst-class:: classref-enumeration-constant
:ref:`AnisotropicFiltering<enum_Viewport_AnisotropicFiltering>` **ANISOTROPY_2X** = ``1``
Utilizza il filtro anisotropico 2×.
.. _class_Viewport_constant_ANISOTROPY_4X:
.. rst-class:: classref-enumeration-constant
:ref:`AnisotropicFiltering<enum_Viewport_AnisotropicFiltering>` **ANISOTROPY_4X** = ``2``
Utilizza il filtro anisotropico 4×. Questo è il valore predefinito.
.. _class_Viewport_constant_ANISOTROPY_8X:
.. rst-class:: classref-enumeration-constant
:ref:`AnisotropicFiltering<enum_Viewport_AnisotropicFiltering>` **ANISOTROPY_8X** = ``3``
Utilizza il filtro anisotropico 8×.
.. _class_Viewport_constant_ANISOTROPY_16X:
.. rst-class:: classref-enumeration-constant
:ref:`AnisotropicFiltering<enum_Viewport_AnisotropicFiltering>` **ANISOTROPY_16X** = ``4``
Utilizza il filtro anisotropico 16×.
.. _class_Viewport_constant_ANISOTROPY_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`AnisotropicFiltering<enum_Viewport_AnisotropicFiltering>` **ANISOTROPY_MAX** = ``5``
Rappresenta la dimensione dell'enumerazione :ref:`AnisotropicFiltering<enum_Viewport_AnisotropicFiltering>`.
.. rst-class:: classref-item-separator
----
.. _enum_Viewport_ScreenSpaceAA:
.. rst-class:: classref-enumeration
enum **ScreenSpaceAA**: :ref:`🔗<enum_Viewport_ScreenSpaceAA>`
.. _class_Viewport_constant_SCREEN_SPACE_AA_DISABLED:
.. rst-class:: classref-enumeration-constant
:ref:`ScreenSpaceAA<enum_Viewport_ScreenSpaceAA>` **SCREEN_SPACE_AA_DISABLED** = ``0``
Non eseguire alcun antialiasing nella post-elaborazione dell'intero schermo.
.. _class_Viewport_constant_SCREEN_SPACE_AA_FXAA:
.. rst-class:: classref-enumeration-constant
:ref:`ScreenSpaceAA<enum_Viewport_ScreenSpaceAA>` **SCREEN_SPACE_AA_FXAA** = ``1``
Usa un antialiasing approssimativo veloce. FXAA è un metodo di antialiasing spazio-schermo popolare, che è veloce ma renderà l'immagine sfocata, specialmente a risoluzioni più basse. Può comunque funzionare abbastanza bene a risoluzioni elevate come 1440p e 4K.
.. _class_Viewport_constant_SCREEN_SPACE_AA_SMAA:
.. rst-class:: classref-enumeration-constant
:ref:`ScreenSpaceAA<enum_Viewport_ScreenSpaceAA>` **SCREEN_SPACE_AA_SMAA** = ``2``
Utilizza l'antialiasing morfologico subpixel. SMAA può produrre risultati più nitidi di FXAA, ma con un costo in termini di prestazioni leggermente superiore.
.. _class_Viewport_constant_SCREEN_SPACE_AA_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`ScreenSpaceAA<enum_Viewport_ScreenSpaceAA>` **SCREEN_SPACE_AA_MAX** = ``3``
Rappresenta la dimensione dell'enumerazione :ref:`ScreenSpaceAA<enum_Viewport_ScreenSpaceAA>`.
.. rst-class:: classref-item-separator
----
.. _enum_Viewport_RenderInfo:
.. rst-class:: classref-enumeration
enum **RenderInfo**: :ref:`🔗<enum_Viewport_RenderInfo>`
.. _class_Viewport_constant_RENDER_INFO_OBJECTS_IN_FRAME:
.. rst-class:: classref-enumeration-constant
:ref:`RenderInfo<enum_Viewport_RenderInfo>` **RENDER_INFO_OBJECTS_IN_FRAME** = ``0``
Quantità di oggetti nell'inquadratura.
.. _class_Viewport_constant_RENDER_INFO_PRIMITIVES_IN_FRAME:
.. rst-class:: classref-enumeration-constant
:ref:`RenderInfo<enum_Viewport_RenderInfo>` **RENDER_INFO_PRIMITIVES_IN_FRAME** = ``1``
Quantità di vertici nell'inquadratura.
.. _class_Viewport_constant_RENDER_INFO_DRAW_CALLS_IN_FRAME:
.. rst-class:: classref-enumeration-constant
:ref:`RenderInfo<enum_Viewport_RenderInfo>` **RENDER_INFO_DRAW_CALLS_IN_FRAME** = ``2``
Quantità di chiamate di disegno nell'inquadratura.
.. _class_Viewport_constant_RENDER_INFO_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`RenderInfo<enum_Viewport_RenderInfo>` **RENDER_INFO_MAX** = ``3``
Rappresenta la dimensione dell'enumerazione :ref:`RenderInfo<enum_Viewport_RenderInfo>`.
.. rst-class:: classref-item-separator
----
.. _enum_Viewport_RenderInfoType:
.. rst-class:: classref-enumeration
enum **RenderInfoType**: :ref:`🔗<enum_Viewport_RenderInfoType>`
.. _class_Viewport_constant_RENDER_INFO_TYPE_VISIBLE:
.. rst-class:: classref-enumeration-constant
:ref:`RenderInfoType<enum_Viewport_RenderInfoType>` **RENDER_INFO_TYPE_VISIBLE** = ``0``
Passaggio di rendering visibile (ombre escluse).
.. _class_Viewport_constant_RENDER_INFO_TYPE_SHADOW:
.. rst-class:: classref-enumeration-constant
:ref:`RenderInfoType<enum_Viewport_RenderInfoType>` **RENDER_INFO_TYPE_SHADOW** = ``1``
Passaggio di rendering delle ombre. Gli oggetti saranno renderizzati più volte a seconda della quantità di luci con ombre e del numero di suddivisioni delle ombre direzionali.
.. _class_Viewport_constant_RENDER_INFO_TYPE_CANVAS:
.. rst-class:: classref-enumeration-constant
:ref:`RenderInfoType<enum_Viewport_RenderInfoType>` **RENDER_INFO_TYPE_CANVAS** = ``2``
Rendering degli elementi canvas. Include tutto il rendering 2D.
.. _class_Viewport_constant_RENDER_INFO_TYPE_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`RenderInfoType<enum_Viewport_RenderInfoType>` **RENDER_INFO_TYPE_MAX** = ``3``
Rappresenta la dimensione dell'enumerazione :ref:`RenderInfoType<enum_Viewport_RenderInfoType>`.
.. rst-class:: classref-item-separator
----
.. _enum_Viewport_DebugDraw:
.. rst-class:: classref-enumeration
enum **DebugDraw**: :ref:`🔗<enum_Viewport_DebugDraw>`
.. _class_Viewport_constant_DEBUG_DRAW_DISABLED:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_DISABLED** = ``0``
Gli oggetti sono visualizzati normalmente.
.. _class_Viewport_constant_DEBUG_DRAW_UNSHADED:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_UNSHADED** = ``1``
Gli oggetti sono visualizzati senza informazioni sulla luce.
.. _class_Viewport_constant_DEBUG_DRAW_LIGHTING:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_LIGHTING** = ``2``
Gli oggetti sono visualizzati senza texture e solo con le informazioni sull'illuminazione.
\ **Nota:** Quando si utilizza questa modalità di disegno di debug, gli shader personalizzati sono ignorati, poiché tutti i materiali nella scena utilizzano temporaneamente un materiale di debug. Ciò significa che il risultato delle funzioni degli shader personalizzati (come lo scostamento di vertici) non sarà più visibile quando si utilizza questa modalità.
.. _class_Viewport_constant_DEBUG_DRAW_OVERDRAW:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_OVERDRAW** = ``3``
Gli oggetti sono visualizzati semi-trasparenti con fusione additiva, così per vedere dove si stanno disegnando uno sopra l'altro. Un overdraw più alto significa che si sta sprecando tempo di calcolo disegnando pixel che sono nascosti dietro altri.
\ **Nota:** Quando si utilizza questa modalità di disegno di debug, gli shader personalizzati sono ignorati, poiché tutti i materiali nella scena utilizzano temporaneamente un materiale di debug. Ciò significa che il risultato delle funzioni degli shader personalizzati (come lo scostamento di vertici) non sarà più visibile quando si utilizza questa modalità.
.. _class_Viewport_constant_DEBUG_DRAW_WIREFRAME:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_WIREFRAME** = ``4``
Gli oggetti sono visualizzati come modelli fildiferro.
\ **Nota:** È necessario chiamare :ref:`RenderingServer.set_debug_generate_wireframes()<class_RenderingServer_method_set_debug_generate_wireframes>` prima di caricare qualsiasi mesh affinché i fildiferro siano visibili quando si utilizza il renderer Compatibilità.
.. _class_Viewport_constant_DEBUG_DRAW_NORMAL_BUFFER:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_NORMAL_BUFFER** = ``5``
Gli oggetti sono visualizzati senza informazioni sull'illuminazione e le loro texture sono sostituite dalla mappatura normale.
\ **Nota:** Supportato solo quando si utilizza i metodo di rendering Forward+.
.. _class_Viewport_constant_DEBUG_DRAW_VOXEL_GI_ALBEDO:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_VOXEL_GI_ALBEDO** = ``6``
Gli oggetti sono visualizzati solo con il valore di albedo dai :ref:`VoxelGI<class_VoxelGI>`. Richiede almeno un nodo :ref:`VoxelGI<class_VoxelGI>` visibile che è stato elaborato affinché abbia un effetto tangibile.
\ **Nota:** Supportato solo quando si utilizza il metodo di rendering Forward+.
.. _class_Viewport_constant_DEBUG_DRAW_VOXEL_GI_LIGHTING:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_VOXEL_GI_LIGHTING** = ``7``
Gli oggetti sono visualizzati solo con il valore di illuminazione dai :ref:`VoxelGI<class_VoxelGI>`. Richiede almeno un nodo :ref:`VoxelGI<class_VoxelGI>` visibile che è stato elaborato affinché abbia un effetto tangibile.
\ **Nota:** Supportato solo quando si utilizza il metodo di rendering Forward+.
.. _class_Viewport_constant_DEBUG_DRAW_VOXEL_GI_EMISSION:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_VOXEL_GI_EMISSION** = ``8``
Gli oggetti sono visualizzati solo con il colore di emissione dai :ref:`VoxelGI<class_VoxelGI>`. Richiede almeno un nodo :ref:`VoxelGI<class_VoxelGI>` visibile che è stato elaborato affinché abbia un effetto tangibile.
\ **Nota:** Supportato solo quando si utilizza il metodo di rendering Forward+.
.. _class_Viewport_constant_DEBUG_DRAW_SHADOW_ATLAS:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_SHADOW_ATLAS** = ``9``
Disegna l'atlante delle ombre che memorizza le ombre degli :ref:`OmniLight3D<class_OmniLight3D>` e gli :ref:`SpotLight3D<class_SpotLight3D>` nel quadrante in alto a sinistra della **Viewport**.
.. _class_Viewport_constant_DEBUG_DRAW_DIRECTIONAL_SHADOW_ATLAS:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_DIRECTIONAL_SHADOW_ATLAS** = ``10``
Disegna l'atlante delle ombre che memorizza le ombre provenienti dai :ref:`DirectionalLight3D<class_DirectionalLight3D>` nel quadrante superiore sinistro della **Viewport**.
.. _class_Viewport_constant_DEBUG_DRAW_SCENE_LUMINANCE:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_SCENE_LUMINANCE** = ``11``
Disegna il buffer di luminanza della scena (se disponibile) nel quadrante superiore sinistro della **Viewport**.
\ **Nota:** Supportato solo quando si utilizzano i metodi di rendering Forward+ o Mobile.
.. _class_Viewport_constant_DEBUG_DRAW_SSAO:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_SSAO** = ``12``
Disegna la texture di occlusione ambientale dello spazio dello schermo anziché la scena, in modo che si possa vedere chiaramente come influisce sugli oggetti. Affinché questa modalità di visualizzazione funzioni, è necessario che :ref:`Environment.ssao_enabled<class_Environment_property_ssao_enabled>` sia impostato nel proprio :ref:`WorldEnvironment<class_WorldEnvironment>`.
\ **Nota:** Supportato solo quando si utilizza i metodo di rendering Forward+.
.. _class_Viewport_constant_DEBUG_DRAW_SSIL:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_SSIL** = ``13``
Disegna la texture di illuminazione indiretta nello spazio dello schermo anziché la scena, in modo che si possa vedere chiaramente come influisce sugli oggetti. Affinché questa modalità di visualizzazione funzioni, è necessario che :ref:`Environment.ssil_enabled<class_Environment_property_ssil_enabled>` sia impostato nel proprio :ref:`WorldEnvironment<class_WorldEnvironment>`.
\ **Nota:** Supportato solo quando si utilizza i metodo di rendering Forward+.
.. _class_Viewport_constant_DEBUG_DRAW_PSSM_SPLITS:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_PSSM_SPLITS** = ``14``
Colora ogni divisione PSSM per i :ref:`DirectionalLight3D<class_DirectionalLight3D>` nella scena con un colore diverso in modo da poter vedere dove si trovano le divisioni. In ordine (dal più vicino al più lontano dalla telecamera), sono colorate in rosso, verde, blu e giallo.
\ **Nota:** Quando si utilizza questa modalità di disegno di debug, gli shader personalizzati sono ignorati, poiché tutti i materiali nella scena utilizzano temporaneamente un materiale di debug. Ciò significa che il risultato delle funzioni degli shader personalizzati (come lo scostamento di vertici) non sarà più visibile quando si utilizza questa modalità.
\ **Nota:** Supportato solo quando si utilizzano i metodi di rendering Forward+ o Mobile.
.. _class_Viewport_constant_DEBUG_DRAW_DECAL_ATLAS:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_DECAL_ATLAS** = ``15``
Disegna l'atlante delle decalcomanie utilizzato dalle :ref:`Decal<class_Decal>` e dalle texture di proiettori di luce nel quadrante superiore sinistro della **Viewport**.
\ **Nota:** Supportato solo quando si utilizzano i metodi di rendering Forward+ o Mobile.
.. _class_Viewport_constant_DEBUG_DRAW_SDFGI:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_SDFGI** = ``16``
Disegna le cascate utilizzate per renderizzare l'illuminazione globale con signed distance field (SDFGI).
Non fa nulla se :ref:`Environment.sdfgi_enabled<class_Environment_property_sdfgi_enabled>` dell'ambiente attuale è ``false``.
\ **Nota:** Supportato solo quando si utilizza i metodo di rendering Forward+.
.. _class_Viewport_constant_DEBUG_DRAW_SDFGI_PROBES:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_SDFGI_PROBES** = ``17``
Draws the probes used for signed distance field global illumination (SDFGI).
When in the editor, left-clicking a probe will display additional bright dots that show its occlusion information. A white dot means the light is not occluded at all at the dot's position, while a red dot means the light is fully occluded. Intermediate values are possible.
Does nothing if the current environment's :ref:`Environment.sdfgi_enabled<class_Environment_property_sdfgi_enabled>` is ``false``.
\ **Note:** Only supported when using the Forward+ rendering method.
.. _class_Viewport_constant_DEBUG_DRAW_GI_BUFFER:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_GI_BUFFER** = ``18``
Disegna il buffer utilizzato per l'illuminazione globale da :ref:`VoxelGI<class_VoxelGI>` o SDFGI. Richiede che :ref:`VoxelGI<class_VoxelGI>` (almeno un nodo VoxelGI elaborato visibile) o SDFGI (:ref:`Environment.sdfgi_enabled<class_Environment_property_sdfgi_enabled>`) sia abilitato affinché abbia un effetto tangibile.
\ **Nota:** Supportato solo quando si utilizza il metodo di rendering Forward+.
.. _class_Viewport_constant_DEBUG_DRAW_DISABLE_LOD:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_DISABLE_LOD** = ``19``
Disegna tutti gli oggetti al loro numero massimo di poligoni, a prescindere dalla loro distanza dalla telecamera. Nessun basso livello di dettaglio (LOD) è applicato.
.. _class_Viewport_constant_DEBUG_DRAW_CLUSTER_OMNI_LIGHTS:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_CLUSTER_OMNI_LIGHTS** = ``20``
Disegna il cluster utilizzato dai nodi :ref:`OmniLight3D<class_OmniLight3D>` per ottimizzare il rendering della luce.
\ **Nota:** Supportato solo quando si utilizza i metodo di rendering Forward+.
.. _class_Viewport_constant_DEBUG_DRAW_CLUSTER_SPOT_LIGHTS:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_CLUSTER_SPOT_LIGHTS** = ``21``
Disegna il cluster utilizzato dai nodi :ref:`SpotLight3D<class_SpotLight3D>` per ottimizzare il rendering della luce.
\ **Nota:** Supportato solo quando si utilizza i metodo di rendering Forward+.
.. _class_Viewport_constant_DEBUG_DRAW_CLUSTER_DECALS:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_CLUSTER_DECALS** = ``22``
Disegna il cluster utilizzato dai nodi :ref:`Decal<class_Decal>` per ottimizzare il rendering delle decalcomanie.
\ **Nota:** Supportato solo quando si utilizza i metodo di rendering Forward+.
.. _class_Viewport_constant_DEBUG_DRAW_CLUSTER_REFLECTION_PROBES:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_CLUSTER_REFLECTION_PROBES** = ``23``
Disegna il cluster utilizzato dai nodi :ref:`ReflectionProbe<class_ReflectionProbe>` per ottimizzare il rendering delle decalcomanie.
\ **Nota:** Supportato solo quando si utilizza i metodo di rendering Forward+.
.. _class_Viewport_constant_DEBUG_DRAW_OCCLUDERS:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_OCCLUDERS** = ``24``
Disegna il buffer utilizzato per l'occlusion culling.
\ **Nota:** Supportato solo quando si utilizzano i metodi di rendering Forward+ o Mobile.
.. _class_Viewport_constant_DEBUG_DRAW_MOTION_VECTORS:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_MOTION_VECTORS** = ``25``
Disegna linee vettoriali sulla viewport per indicare lo spostamento dei pixel tra i frame.
\ **Nota:** Supportato solo quando si utilizza i metodo di rendering Forward+.
.. _class_Viewport_constant_DEBUG_DRAW_INTERNAL_BUFFER:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_INTERNAL_BUFFER** = ``26``
Disegna il buffer interno di risoluzione della scena in uno spazio colore lineare prima di applicare la mappatura dei toni o la post-elaborazione.
\ **Nota:** Supportato solo quando si utilizzano i metodi di rendering Forward+ o Mobile.
.. rst-class:: classref-item-separator
----
.. _enum_Viewport_DefaultCanvasItemTextureFilter:
.. rst-class:: classref-enumeration
enum **DefaultCanvasItemTextureFilter**: :ref:`🔗<enum_Viewport_DefaultCanvasItemTextureFilter>`
.. _class_Viewport_constant_DEFAULT_CANVAS_ITEM_TEXTURE_FILTER_NEAREST:
.. rst-class:: classref-enumeration-constant
:ref:`DefaultCanvasItemTextureFilter<enum_Viewport_DefaultCanvasItemTextureFilter>` **DEFAULT_CANVAS_ITEM_TEXTURE_FILTER_NEAREST** = ``0``
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_Viewport_constant_DEFAULT_CANVAS_ITEM_TEXTURE_FILTER_LINEAR:
.. rst-class:: classref-enumeration-constant
:ref:`DefaultCanvasItemTextureFilter<enum_Viewport_DefaultCanvasItemTextureFilter>` **DEFAULT_CANVAS_ITEM_TEXTURE_FILTER_LINEAR** = ``1``
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_Viewport_constant_DEFAULT_CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS:
.. rst-class:: classref-enumeration-constant
:ref:`DefaultCanvasItemTextureFilter<enum_Viewport_DefaultCanvasItemTextureFilter>` **DEFAULT_CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS** = ``2``
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_Viewport_constant_DEFAULT_CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS:
.. rst-class:: classref-enumeration-constant
:ref:`DefaultCanvasItemTextureFilter<enum_Viewport_DefaultCanvasItemTextureFilter>` **DEFAULT_CANVAS_ITEM_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_Viewport_constant_DEFAULT_CANVAS_ITEM_TEXTURE_FILTER_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`DefaultCanvasItemTextureFilter<enum_Viewport_DefaultCanvasItemTextureFilter>` **DEFAULT_CANVAS_ITEM_TEXTURE_FILTER_MAX** = ``4``
Rappresenta la dimensione dell'enumerazione :ref:`DefaultCanvasItemTextureFilter<enum_Viewport_DefaultCanvasItemTextureFilter>`.
.. rst-class:: classref-item-separator
----
.. _enum_Viewport_DefaultCanvasItemTextureRepeat:
.. rst-class:: classref-enumeration
enum **DefaultCanvasItemTextureRepeat**: :ref:`🔗<enum_Viewport_DefaultCanvasItemTextureRepeat>`
.. _class_Viewport_constant_DEFAULT_CANVAS_ITEM_TEXTURE_REPEAT_DISABLED:
.. rst-class:: classref-enumeration-constant
:ref:`DefaultCanvasItemTextureRepeat<enum_Viewport_DefaultCanvasItemTextureRepeat>` **DEFAULT_CANVAS_ITEM_TEXTURE_REPEAT_DISABLED** = ``0``
Disattiva la ripetizione delle texture. Invece, quando si leggono gli UV al di fuori dell'intervallo tra 0 e 1, il valore sarà limitato sui bordi della texture, portando a un aspetto allargato dei bordi della texture.
.. _class_Viewport_constant_DEFAULT_CANVAS_ITEM_TEXTURE_REPEAT_ENABLED:
.. rst-class:: classref-enumeration-constant
:ref:`DefaultCanvasItemTextureRepeat<enum_Viewport_DefaultCanvasItemTextureRepeat>` **DEFAULT_CANVAS_ITEM_TEXTURE_REPEAT_ENABLED** = ``1``
Abilita la ripetizione della texture quando le coordinate UV sono all di fuori dell'intervallo da 0 a 1. Se si utilizza una delle modalità di filtraggio lineare, ciò può provocare artefatti ai bordi di una texture quando il campionatore filtra attraverso i bordi della texture.
.. _class_Viewport_constant_DEFAULT_CANVAS_ITEM_TEXTURE_REPEAT_MIRROR:
.. rst-class:: classref-enumeration-constant
:ref:`DefaultCanvasItemTextureRepeat<enum_Viewport_DefaultCanvasItemTextureRepeat>` **DEFAULT_CANVAS_ITEM_TEXTURE_REPEAT_MIRROR** = ``2``
Capovolte la texture per la ripetizione in modo che i bordi si allineano invece di cambiare bruscamente.
.. _class_Viewport_constant_DEFAULT_CANVAS_ITEM_TEXTURE_REPEAT_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`DefaultCanvasItemTextureRepeat<enum_Viewport_DefaultCanvasItemTextureRepeat>` **DEFAULT_CANVAS_ITEM_TEXTURE_REPEAT_MAX** = ``3``
Rappresenta la dimensione dell'enumerazione :ref:`DefaultCanvasItemTextureRepeat<enum_Viewport_DefaultCanvasItemTextureRepeat>`.
.. rst-class:: classref-item-separator
----
.. _enum_Viewport_SDFOversize:
.. rst-class:: classref-enumeration
enum **SDFOversize**: :ref:`🔗<enum_Viewport_SDFOversize>`
.. _class_Viewport_constant_SDF_OVERSIZE_100_PERCENT:
.. rst-class:: classref-enumeration-constant
:ref:`SDFOversize<enum_Viewport_SDFOversize>` **SDF_OVERSIZE_100_PERCENT** = ``0``
Il campo di distanza con segno copre solo il rettangolo della viewport.
.. _class_Viewport_constant_SDF_OVERSIZE_120_PERCENT:
.. rst-class:: classref-enumeration-constant
:ref:`SDFOversize<enum_Viewport_SDFOversize>` **SDF_OVERSIZE_120_PERCENT** = ``1``
Il campo di distanza con segno è esteso per coprire il 20% delle dimensioni della viewport attorno ai bordi.
.. _class_Viewport_constant_SDF_OVERSIZE_150_PERCENT:
.. rst-class:: classref-enumeration-constant
:ref:`SDFOversize<enum_Viewport_SDFOversize>` **SDF_OVERSIZE_150_PERCENT** = ``2``
Il campo di distanza con segno è esteso per coprire il 50% delle dimensioni della viewport attorno ai bordi.
.. _class_Viewport_constant_SDF_OVERSIZE_200_PERCENT:
.. rst-class:: classref-enumeration-constant
:ref:`SDFOversize<enum_Viewport_SDFOversize>` **SDF_OVERSIZE_200_PERCENT** = ``3``
Il campo di distanza con segno è esteso per coprire il 100% (il doppio) delle dimensioni della viewport attorno ai bordi.
.. _class_Viewport_constant_SDF_OVERSIZE_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`SDFOversize<enum_Viewport_SDFOversize>` **SDF_OVERSIZE_MAX** = ``4``
Rappresenta la dimensione dell'enumerazione :ref:`SDFOversize<enum_Viewport_SDFOversize>`.
.. rst-class:: classref-item-separator
----
.. _enum_Viewport_SDFScale:
.. rst-class:: classref-enumeration
enum **SDFScale**: :ref:`🔗<enum_Viewport_SDFScale>`
.. _class_Viewport_constant_SDF_SCALE_100_PERCENT:
.. rst-class:: classref-enumeration-constant
:ref:`SDFScale<enum_Viewport_SDFScale>` **SDF_SCALE_100_PERCENT** = ``0``
Il campo di distanza con segno è visualizzato alla risoluzione piena.
.. _class_Viewport_constant_SDF_SCALE_50_PERCENT:
.. rst-class:: classref-enumeration-constant
:ref:`SDFScale<enum_Viewport_SDFScale>` **SDF_SCALE_50_PERCENT** = ``1``
Il campo di distanza con segno è visualizzato a metà della risoluzione di questa viewport.
.. _class_Viewport_constant_SDF_SCALE_25_PERCENT:
.. rst-class:: classref-enumeration-constant
:ref:`SDFScale<enum_Viewport_SDFScale>` **SDF_SCALE_25_PERCENT** = ``2``
Il campo della distanza con segno è visualizzato a un quarto della risoluzione di questa viewport.
.. _class_Viewport_constant_SDF_SCALE_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`SDFScale<enum_Viewport_SDFScale>` **SDF_SCALE_MAX** = ``3``
Rappresenta la dimensione dell'enumerazione :ref:`SDFScale<enum_Viewport_SDFScale>`.
.. rst-class:: classref-item-separator
----
.. _enum_Viewport_VRSMode:
.. rst-class:: classref-enumeration
enum **VRSMode**: :ref:`🔗<enum_Viewport_VRSMode>`
.. _class_Viewport_constant_VRS_DISABLED:
.. rst-class:: classref-enumeration-constant
:ref:`VRSMode<enum_Viewport_VRSMode>` **VRS_DISABLED** = ``0``
Il Variable Rate Shading è disattivato.
.. _class_Viewport_constant_VRS_TEXTURE:
.. rst-class:: classref-enumeration-constant
:ref:`VRSMode<enum_Viewport_VRSMode>` **VRS_TEXTURE** = ``1``
Il Variable Rate Shading usa una texture. Nota, per la stereoscopia usa un atlante di texture con una texture per ogni vista.
.. _class_Viewport_constant_VRS_XR:
.. rst-class:: classref-enumeration-constant
:ref:`VRSMode<enum_Viewport_VRSMode>` **VRS_XR** = ``2``
La texture del Variable Rate Shading è fornita dall'interfaccia :ref:`XRInterface<class_XRInterface>` primaria.
.. _class_Viewport_constant_VRS_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`VRSMode<enum_Viewport_VRSMode>` **VRS_MAX** = ``3``
Rappresenta la dimensione dell'enumerazione :ref:`VRSMode<enum_Viewport_VRSMode>`.
.. rst-class:: classref-item-separator
----
.. _enum_Viewport_VRSUpdateMode:
.. rst-class:: classref-enumeration
enum **VRSUpdateMode**: :ref:`🔗<enum_Viewport_VRSUpdateMode>`
.. _class_Viewport_constant_VRS_UPDATE_DISABLED:
.. rst-class:: classref-enumeration-constant
:ref:`VRSUpdateMode<enum_Viewport_VRSUpdateMode>` **VRS_UPDATE_DISABLED** = ``0``
La texture di ingresso per il variable rate shading non sarà elaborata.
.. _class_Viewport_constant_VRS_UPDATE_ONCE:
.. rst-class:: classref-enumeration-constant
:ref:`VRSUpdateMode<enum_Viewport_VRSUpdateMode>` **VRS_UPDATE_ONCE** = ``1``
La texture di ingresso per il variable rate shading sarà elaborata una sola volta.
.. _class_Viewport_constant_VRS_UPDATE_ALWAYS:
.. rst-class:: classref-enumeration-constant
:ref:`VRSUpdateMode<enum_Viewport_VRSUpdateMode>` **VRS_UPDATE_ALWAYS** = ``2``
La texture di ingresso per il variable rate shading sarà elaborata ogni frame.
.. _class_Viewport_constant_VRS_UPDATE_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`VRSUpdateMode<enum_Viewport_VRSUpdateMode>` **VRS_UPDATE_MAX** = ``3``
Rappresenta la dimensione dell'enumerazione :ref:`VRSUpdateMode<enum_Viewport_VRSUpdateMode>`.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descrizioni delle proprietà
------------------------------------------------------
.. _class_Viewport_property_anisotropic_filtering_level:
.. rst-class:: classref-property
:ref:`AnisotropicFiltering<enum_Viewport_AnisotropicFiltering>` **anisotropic_filtering_level** = ``2`` :ref:`🔗<class_Viewport_property_anisotropic_filtering_level>`
.. rst-class:: classref-property-setget
- |void| **set_anisotropic_filtering_level**\ (\ value\: :ref:`AnisotropicFiltering<enum_Viewport_AnisotropicFiltering>`\ )
- :ref:`AnisotropicFiltering<enum_Viewport_AnisotropicFiltering>` **get_anisotropic_filtering_level**\ (\ )
Imposta il numero massimo di campioni da ricavare quando si usa il filtro anisotropico sulle texture (come potenza di due). Un numero di campioni più alto produrrà texture più nitide ad angoli obliqui, ma è più costoso da calcolare. Un valore di ``0`` disabilita forzatamente il filtro anisotropico, anche sui materiali in cui è abilitato.
Il livello di filtro anisotropico influisce anche su decalcomanie e proiettori di luce se sono configurati per usare il filtro anisotropico. Vedi :ref:`ProjectSettings.rendering/textures/decals/filter<class_ProjectSettings_property_rendering/textures/decals/filter>` e :ref:`ProjectSettings.rendering/textures/light_projectors/filter<class_ProjectSettings_property_rendering/textures/light_projectors/filter>`.
\ **Nota:** In 3D, per fare in modo che questa impostazione abbia effetto, imposta :ref:`BaseMaterial3D.texture_filter<class_BaseMaterial3D_property_texture_filter>` su :ref:`BaseMaterial3D.TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC<class_BaseMaterial3D_constant_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC>` o :ref:`BaseMaterial3D.TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC<class_BaseMaterial3D_constant_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC>` sui materiali.
\ **Nota:** In 2D, per fare in modo che questa impostazione abbia effetto, imposta :ref:`CanvasItem.texture_filter<class_CanvasItem_property_texture_filter>` su :ref:`CanvasItem.TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC<class_CanvasItem_constant_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC>` o :ref:`CanvasItem.TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC<class_CanvasItem_constant_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC>` sul nodo :ref:`CanvasItem<class_CanvasItem>` che visualizza la texture (o in :ref:`CanvasTexture<class_CanvasTexture>`). Tuttavia, il filtro anisotropico è raramente utile in 2D, quindi abilitalo per le texture in 2D solo se produce una notevole differenza visiva.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_audio_listener_enable_2d:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **audio_listener_enable_2d** = ``false`` :ref:`🔗<class_Viewport_property_audio_listener_enable_2d>`
.. rst-class:: classref-property-setget
- |void| **set_as_audio_listener_2d**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_audio_listener_2d**\ (\ )
Se ``true``, la viewport elaborerà i flussi audio 2D.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_audio_listener_enable_3d:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **audio_listener_enable_3d** = ``false`` :ref:`🔗<class_Viewport_property_audio_listener_enable_3d>`
.. rst-class:: classref-property-setget
- |void| **set_as_audio_listener_3d**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_audio_listener_3d**\ (\ )
Se ``true``, la viewport elaborerà i flussi audio 3D.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_canvas_cull_mask:
.. rst-class:: classref-property
:ref:`int<class_int>` **canvas_cull_mask** = ``4294967295`` :ref:`🔗<class_Viewport_property_canvas_cull_mask>`
.. rst-class:: classref-property-setget
- |void| **set_canvas_cull_mask**\ (\ value\: :ref:`int<class_int>`\ )
- :ref:`int<class_int>` **get_canvas_cull_mask**\ (\ )
The rendering layers in which this **Viewport** renders :ref:`CanvasItem<class_CanvasItem>` nodes.
\ **Note:** A :ref:`CanvasItem<class_CanvasItem>` does not inherit its parents' visibility layers. See :ref:`CanvasItem.visibility_layer<class_CanvasItem_property_visibility_layer>`'s description for details.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_canvas_item_default_texture_filter:
.. rst-class:: classref-property
:ref:`DefaultCanvasItemTextureFilter<enum_Viewport_DefaultCanvasItemTextureFilter>` **canvas_item_default_texture_filter** = ``1`` :ref:`🔗<class_Viewport_property_canvas_item_default_texture_filter>`
.. rst-class:: classref-property-setget
- |void| **set_default_canvas_item_texture_filter**\ (\ value\: :ref:`DefaultCanvasItemTextureFilter<enum_Viewport_DefaultCanvasItemTextureFilter>`\ )
- :ref:`DefaultCanvasItemTextureFilter<enum_Viewport_DefaultCanvasItemTextureFilter>` **get_default_canvas_item_texture_filter**\ (\ )
The default filter mode used by :ref:`CanvasItem<class_CanvasItem>` nodes in this viewport.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_canvas_item_default_texture_repeat:
.. rst-class:: classref-property
:ref:`DefaultCanvasItemTextureRepeat<enum_Viewport_DefaultCanvasItemTextureRepeat>` **canvas_item_default_texture_repeat** = ``0`` :ref:`🔗<class_Viewport_property_canvas_item_default_texture_repeat>`
.. rst-class:: classref-property-setget
- |void| **set_default_canvas_item_texture_repeat**\ (\ value\: :ref:`DefaultCanvasItemTextureRepeat<enum_Viewport_DefaultCanvasItemTextureRepeat>`\ )
- :ref:`DefaultCanvasItemTextureRepeat<enum_Viewport_DefaultCanvasItemTextureRepeat>` **get_default_canvas_item_texture_repeat**\ (\ )
The default repeat mode used by :ref:`CanvasItem<class_CanvasItem>` nodes in this viewport.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_canvas_transform:
.. rst-class:: classref-property
:ref:`Transform2D<class_Transform2D>` **canvas_transform** :ref:`🔗<class_Viewport_property_canvas_transform>`
.. rst-class:: classref-property-setget
- |void| **set_canvas_transform**\ (\ value\: :ref:`Transform2D<class_Transform2D>`\ )
- :ref:`Transform2D<class_Transform2D>` **get_canvas_transform**\ (\ )
La trasformazione di canvas della viewport, utile per cambiare le posizioni sullo schermo di tutti i :ref:`CanvasItem<class_CanvasItem>` figlio. È relativo alla trasformazione di canvas globale della viewport.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_debug_draw:
.. rst-class:: classref-property
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **debug_draw** = ``0`` :ref:`🔗<class_Viewport_property_debug_draw>`
.. rst-class:: classref-property-setget
- |void| **set_debug_draw**\ (\ value\: :ref:`DebugDraw<enum_Viewport_DebugDraw>`\ )
- :ref:`DebugDraw<enum_Viewport_DebugDraw>` **get_debug_draw**\ (\ )
Modalità di sovrapposizione ("overlay") per testare la geometria renderizzata per motivi di debug.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_disable_3d:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **disable_3d** = ``false`` :ref:`🔗<class_Viewport_property_disable_3d>`
.. rst-class:: classref-property-setget
- |void| **set_disable_3d**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_3d_disabled**\ (\ )
Disattiva il rendering 3D (ma mantiene il rendering 2D).
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_fsr_sharpness:
.. rst-class:: classref-property
:ref:`float<class_float>` **fsr_sharpness** = ``0.2`` :ref:`🔗<class_Viewport_property_fsr_sharpness>`
.. rst-class:: classref-property-setget
- |void| **set_fsr_sharpness**\ (\ value\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_fsr_sharpness**\ (\ )
Determina quanto sarà nitida l'immagine ingrandita quando si usa la modalità di upscaling FSR. La nitidezza si dimezza con ogni numero intero. I valori variano da 0,0 (più nitido) a 2,0. I valori superiori a 2,0 non faranno una differenza evidente.
Per controllare questa proprietà nella viewport radice, cambia l'impostazione del progetto :ref:`ProjectSettings.rendering/scaling_3d/fsr_sharpness<class_ProjectSettings_property_rendering/scaling_3d/fsr_sharpness>`.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_global_canvas_transform:
.. rst-class:: classref-property
:ref:`Transform2D<class_Transform2D>` **global_canvas_transform** :ref:`🔗<class_Viewport_property_global_canvas_transform>`
.. rst-class:: classref-property-setget
- |void| **set_global_canvas_transform**\ (\ value\: :ref:`Transform2D<class_Transform2D>`\ )
- :ref:`Transform2D<class_Transform2D>` **get_global_canvas_transform**\ (\ )
La trasformazione globale di canvas della viewport. La trasformazione di canvas è relativa a questa.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_gui_disable_input:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **gui_disable_input** = ``false`` :ref:`🔗<class_Viewport_property_gui_disable_input>`
.. rst-class:: classref-property-setget
- |void| **set_disable_input**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_input_disabled**\ (\ )
Se ``true``, la viewport non riceverà eventi di input.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_gui_drag_threshold:
.. rst-class:: classref-property
:ref:`int<class_int>` **gui_drag_threshold** = ``10`` :ref:`🔗<class_Viewport_property_gui_drag_threshold>`
.. rst-class:: classref-property-setget
- |void| **set_drag_threshold**\ (\ value\: :ref:`int<class_int>`\ )
- :ref:`int<class_int>` **get_drag_threshold**\ (\ )
The minimum distance the mouse cursor must move while pressed before a drag operation begins.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_gui_embed_subwindows:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **gui_embed_subwindows** = ``false`` :ref:`🔗<class_Viewport_property_gui_embed_subwindows>`
.. rst-class:: classref-property-setget
- |void| **set_embedding_subwindows**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_embedding_subwindows**\ (\ )
Se ``true``, le sottofinestre (popup e finestre di dialogo) saranno incorporate all'interno della finestra dell'applicazione come nodi simili a controlli. Se ``false``, appariranno come finestre separate gestite dal sistema operativo.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_gui_snap_controls_to_pixels:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **gui_snap_controls_to_pixels** = ``true`` :ref:`🔗<class_Viewport_property_gui_snap_controls_to_pixels>`
.. rst-class:: classref-property-setget
- |void| **set_snap_controls_to_pixels**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_snap_controls_to_pixels_enabled**\ (\ )
Se ``true``, i controlli GUI sulla viewport si allineano perfettamente ai pixel.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_handle_input_locally:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **handle_input_locally** = ``true`` :ref:`🔗<class_Viewport_property_handle_input_locally>`
.. rst-class:: classref-property-setget
- |void| **set_handle_input_locally**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_handling_input_locally**\ (\ )
Se ``true``, questa viewport contrassegnerà gli eventi di input in arrivo come gestiti da sé stessa. Se ``false``, ciò viene invece fatto dalla prima viewport padre impostata per gestire l'input localmente.
Un :ref:`SubViewportContainer<class_SubViewportContainer>` imposterà automaticamente questa proprietà su ``false`` per la **Viewport** contenuta al suo interno.
Vedi anche :ref:`set_input_as_handled()<class_Viewport_method_set_input_as_handled>` e :ref:`is_input_handled()<class_Viewport_method_is_input_handled>`.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_mesh_lod_threshold:
.. rst-class:: classref-property
:ref:`float<class_float>` **mesh_lod_threshold** = ``1.0`` :ref:`🔗<class_Viewport_property_mesh_lod_threshold>`
.. rst-class:: classref-property-setget
- |void| **set_mesh_lod_threshold**\ (\ value\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_mesh_lod_threshold**\ (\ )
Il bias LOD automatico da usare per le mesh renderizzate all'interno della **Viewport** (analogo a :ref:`ReflectionProbe.mesh_lod_threshold<class_ReflectionProbe_property_mesh_lod_threshold>`). Valori più alti useranno versioni meno dettagliate delle mesh che hanno variazioni LOD generate. Se impostato su ``0.0``, il LOD automatico è disabilitato. Aumenta :ref:`mesh_lod_threshold<class_Viewport_property_mesh_lod_threshold>` per migliorare le prestazioni a scapito dei dettagli della geometria.
Per controllare questa proprietà sulla viewport radice, cambia l'impostazione del progetto :ref:`ProjectSettings.rendering/mesh_lod/lod_change/threshold_pixels<class_ProjectSettings_property_rendering/mesh_lod/lod_change/threshold_pixels>`.
\ **Nota:** :ref:`mesh_lod_threshold<class_Viewport_property_mesh_lod_threshold>` non influisce sugli intervalli di visibilità :ref:`GeometryInstance3D<class_GeometryInstance3D>` (noti anche come LOD "manuale" o LOD gerarchico).
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_msaa_2d:
.. rst-class:: classref-property
:ref:`MSAA<enum_Viewport_MSAA>` **msaa_2d** = ``0`` :ref:`🔗<class_Viewport_property_msaa_2d>`
.. rst-class:: classref-property-setget
- |void| **set_msaa_2d**\ (\ value\: :ref:`MSAA<enum_Viewport_MSAA>`\ )
- :ref:`MSAA<enum_Viewport_MSAA>` **get_msaa_2d**\ (\ )
La modalità antialiasing multicampione per il rendering 2D/Canvas. Un numero più alto produce bordi più smussati a scapito di prestazioni notevolmente peggiori. Un valore di :ref:`MSAA_2X<class_Viewport_constant_MSAA_2X>` o :ref:`MSAA_4X<class_Viewport_constant_MSAA_4X>` è il migliore, a meno che non si punti a sistemi di fascia molto alta. Questo non ha alcun effetto sull'aliasing indotto da uno shader o sull'aliasing delle texture.
Vedi anche :ref:`ProjectSettings.rendering/anti_aliasing/quality/msaa_2d<class_ProjectSettings_property_rendering/anti_aliasing/quality/msaa_2d>` e :ref:`RenderingServer.viewport_set_msaa_2d()<class_RenderingServer_method_viewport_set_msaa_2d>`.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_msaa_3d:
.. rst-class:: classref-property
:ref:`MSAA<enum_Viewport_MSAA>` **msaa_3d** = ``0`` :ref:`🔗<class_Viewport_property_msaa_3d>`
.. rst-class:: classref-property-setget
- |void| **set_msaa_3d**\ (\ value\: :ref:`MSAA<enum_Viewport_MSAA>`\ )
- :ref:`MSAA<enum_Viewport_MSAA>` **get_msaa_3d**\ (\ )
La modalità antialiasing multicampione per il rendering 3D. Un numero più alto produce bordi più smussati a scapito di prestazioni notevolmente peggiori. Un valore di :ref:`MSAA_2X<class_Viewport_constant_MSAA_2X>` o :ref:`MSAA_4X<class_Viewport_constant_MSAA_4X>` è il migliore, a meno che non si punti a sistemi di fascia molto alta. Vedi anche bilinear scaling 3D :ref:`scaling_3d_mode<class_Viewport_property_scaling_3d_mode>` per il sovracampionamento, che fornisce una qualità superiore ma è molto più costoso. Questo non ha alcun effetto sull'aliasing indotto da uno shader o sull'aliasing delle texture.
Vedi anche :ref:`ProjectSettings.rendering/anti_aliasing/quality/msaa_3d<class_ProjectSettings_property_rendering/anti_aliasing/quality/msaa_3d>` e :ref:`RenderingServer.viewport_set_msaa_3d()<class_RenderingServer_method_viewport_set_msaa_3d>`.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_oversampling:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **oversampling** = ``true`` :ref:`🔗<class_Viewport_property_oversampling>`
.. rst-class:: classref-property-setget
- |void| **set_use_oversampling**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_using_oversampling**\ (\ )
Se ``true`` e una delle seguenti condizioni sono vere: :ref:`SubViewport.size_2d_override_stretch<class_SubViewport_property_size_2d_override_stretch>` e :ref:`SubViewport.size_2d_override<class_SubViewport_property_size_2d_override>` sono impostati, :ref:`Window.content_scale_factor<class_Window_property_content_scale_factor>` è impostato e il ridimensionamento è abilitato, :ref:`oversampling_override<class_Viewport_property_oversampling_override>` è impostato, il sovracampionamento dei font e di :ref:`DPITexture<class_DPITexture>` sono abilitati.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_oversampling_override:
.. rst-class:: classref-property
:ref:`float<class_float>` **oversampling_override** = ``0.0`` :ref:`🔗<class_Viewport_property_oversampling_override>`
.. rst-class:: classref-property-setget
- |void| **set_oversampling_override**\ (\ value\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_oversampling_override**\ (\ )
Se maggiore di zero, questo valore è utilizzato come fattore di sovracampionamento dei font, altrimenti il sovracampionamento è uguale alla scala della viewport.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_own_world_3d:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **own_world_3d** = ``false`` :ref:`🔗<class_Viewport_property_own_world_3d>`
.. rst-class:: classref-property-setget
- |void| **set_use_own_world_3d**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_using_own_world_3d**\ (\ )
Se ``true``, la viewport utilizzerà una copia unica del :ref:`World3D<class_World3D>` definito in :ref:`world_3d<class_Viewport_property_world_3d>`.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_physics_object_picking:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **physics_object_picking** = ``false`` :ref:`🔗<class_Viewport_property_physics_object_picking>`
.. rst-class:: classref-property-setget
- |void| **set_physics_object_picking**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **get_physics_object_picking**\ (\ )
Se ``true``, gli oggetti renderizzati dalla viewport diventano soggetti al processo di selezione del mouse.
\ **Nota:** Il numero di oggetti selezionabili simultaneamente è limitato a 64 e sono selezionati in un ordine non deterministico, che può essere diverso in ogni processo di selezione.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_physics_object_picking_first_only:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **physics_object_picking_first_only** = ``false`` :ref:`🔗<class_Viewport_property_physics_object_picking_first_only>`
.. rst-class:: classref-property-setget
- |void| **set_physics_object_picking_first_only**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **get_physics_object_picking_first_only**\ (\ )
Se ``true``, il segnale input_event verrà inviato solo a un oggetto di fisica nel processo di selezione del mouse. Se vuoi ottenere solo l'oggetto più in alto, devi anche abilitare :ref:`physics_object_picking_sort<class_Viewport_property_physics_object_picking_sort>`.
Se ``false``, un segnale input_event verrà inviato a tutti gli oggetti di fisica nel processo di selezione del mouse.
Questo si applica solo alla selezione degli oggetto CanvasItem 2D.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_physics_object_picking_sort:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **physics_object_picking_sort** = ``false`` :ref:`🔗<class_Viewport_property_physics_object_picking_sort>`
.. rst-class:: classref-property-setget
- |void| **set_physics_object_picking_sort**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **get_physics_object_picking_sort**\ (\ )
Se ``true``, gli oggetti ricevono eventi di selezione del mouse ordinati principalmente in base al loro :ref:`CanvasItem.z_index<class_CanvasItem_property_z_index>` e secondariamente in base alla loro posizione nell'albero della scena. Se ``false``, l'ordine non è determinato.
\ **Nota:** Questa impostazione è disabilitata per impostazione predefinita a causa del suo potenziale costo computazionale elevato.
\ **Nota:** L'ordinamento avviene dopo aver selezionato gli oggetti selezionabili. A causa della limitazione di 64 oggetti selezionabili contemporaneamente, non è garantito che l'oggetto con il :ref:`CanvasItem.z_index<class_CanvasItem_property_z_index>` più alto riceva l'evento di selezione.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_positional_shadow_atlas_16_bits:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **positional_shadow_atlas_16_bits** = ``true`` :ref:`🔗<class_Viewport_property_positional_shadow_atlas_16_bits>`
.. rst-class:: classref-property-setget
- |void| **set_positional_shadow_atlas_16_bits**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **get_positional_shadow_atlas_16_bits**\ (\ )
Utilizza 16 bit per la mappa di profondità delle ombre omni/spot. Abilitando questa opzione le ombre avranno una precisione minore e potrebbero causare un'acne delle ombre, ma possono migliorare le prestazioni su alcuni dispositivi.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_positional_shadow_atlas_quad_0:
.. rst-class:: classref-property
:ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **positional_shadow_atlas_quad_0** = ``2`` :ref:`🔗<class_Viewport_property_positional_shadow_atlas_quad_0>`
.. rst-class:: classref-property-setget
- |void| **set_positional_shadow_atlas_quadrant_subdiv**\ (\ quadrant\: :ref:`int<class_int>`, subdiv\: :ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>`\ )
- :ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **get_positional_shadow_atlas_quadrant_subdiv**\ (\ quadrant\: :ref:`int<class_int>`\ ) |const|
La quantità di suddivisione del primo quadrante sull'atlante delle ombre.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_positional_shadow_atlas_quad_1:
.. rst-class:: classref-property
:ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **positional_shadow_atlas_quad_1** = ``2`` :ref:`🔗<class_Viewport_property_positional_shadow_atlas_quad_1>`
.. rst-class:: classref-property-setget
- |void| **set_positional_shadow_atlas_quadrant_subdiv**\ (\ quadrant\: :ref:`int<class_int>`, subdiv\: :ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>`\ )
- :ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **get_positional_shadow_atlas_quadrant_subdiv**\ (\ quadrant\: :ref:`int<class_int>`\ ) |const|
La quantità di suddivisione del secondo quadrante sull'atlante delle ombre.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_positional_shadow_atlas_quad_2:
.. rst-class:: classref-property
:ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **positional_shadow_atlas_quad_2** = ``3`` :ref:`🔗<class_Viewport_property_positional_shadow_atlas_quad_2>`
.. rst-class:: classref-property-setget
- |void| **set_positional_shadow_atlas_quadrant_subdiv**\ (\ quadrant\: :ref:`int<class_int>`, subdiv\: :ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>`\ )
- :ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **get_positional_shadow_atlas_quadrant_subdiv**\ (\ quadrant\: :ref:`int<class_int>`\ ) |const|
La quantità di suddivisione del terzo quadrante sull'atlante delle ombre.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_positional_shadow_atlas_quad_3:
.. rst-class:: classref-property
:ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **positional_shadow_atlas_quad_3** = ``4`` :ref:`🔗<class_Viewport_property_positional_shadow_atlas_quad_3>`
.. rst-class:: classref-property-setget
- |void| **set_positional_shadow_atlas_quadrant_subdiv**\ (\ quadrant\: :ref:`int<class_int>`, subdiv\: :ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>`\ )
- :ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **get_positional_shadow_atlas_quadrant_subdiv**\ (\ quadrant\: :ref:`int<class_int>`\ ) |const|
La quantità di suddivisione del quarto quadrante sull'atlante delle ombre.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_positional_shadow_atlas_size:
.. rst-class:: classref-property
:ref:`int<class_int>` **positional_shadow_atlas_size** = ``2048`` :ref:`🔗<class_Viewport_property_positional_shadow_atlas_size>`
.. rst-class:: classref-property-setget
- |void| **set_positional_shadow_atlas_size**\ (\ value\: :ref:`int<class_int>`\ )
- :ref:`int<class_int>` **get_positional_shadow_atlas_size**\ (\ )
La risoluzione dell'atlante delle ombre (utilizzata per luci omnidirezionali e faretti). Il valore è arrotondato alla potenza di 2 più vicina.
\ **Nota:** Se impostato su ``0``, non saranno visibili ombre posizionali. Ciò può migliorare significativamente le prestazioni sui sistemi di fascia bassa riducendo sia il carico della CPU sia il carico della GPU (poiché sono necessarie meno chiamate di disegno per disegnare la scena senza ombre).
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_scaling_3d_mode:
.. rst-class:: classref-property
:ref:`Scaling3DMode<enum_Viewport_Scaling3DMode>` **scaling_3d_mode** = ``0`` :ref:`🔗<class_Viewport_property_scaling_3d_mode>`
.. rst-class:: classref-property-setget
- |void| **set_scaling_3d_mode**\ (\ value\: :ref:`Scaling3DMode<enum_Viewport_Scaling3DMode>`\ )
- :ref:`Scaling3DMode<enum_Viewport_Scaling3DMode>` **get_scaling_3d_mode**\ (\ )
Imposta la modalità di ridimensionamento 3D. Il ridimensionamento bilineare renderizza a risoluzione diversa per sottocampionare o sovracampionare la viewport. FidelityFX Super Resolution 1.0, abbreviato in FSR, è una tecnologia di upscaling che produce immagini di alta qualità a frame rate elevati attraverso un algoritmo di upscaling consapevole dello spazio. FSR è leggermente più costoso di bilineare, ma produce una qualità dell'immagine significativamente più elevata. FSR dovrebbe essere utilizzato ove possibile.
Per controllare questa proprietà sulla viewport radice, cambia l'impostazione del progetto :ref:`ProjectSettings.rendering/scaling_3d/mode<class_ProjectSettings_property_rendering/scaling_3d/mode>`.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_scaling_3d_scale:
.. rst-class:: classref-property
:ref:`float<class_float>` **scaling_3d_scale** = ``1.0`` :ref:`🔗<class_Viewport_property_scaling_3d_scale>`
.. rst-class:: classref-property-setget
- |void| **set_scaling_3d_scale**\ (\ value\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_scaling_3d_scale**\ (\ )
Ridimensiona il buffer di rendering 3D in base alle dimensioni della viewport, utilizzando un filtro immagine specificato in :ref:`ProjectSettings.rendering/scaling_3d/mode<class_ProjectSettings_property_rendering/scaling_3d/mode>` per ridimensionare l'immagine finale alle dimensioni complete della viewport. È possibile utilizzare valori inferiori a ``1.0`` per velocizzare il rendering 3D a scapito della qualità (sottocampionamento). Valori superiori a ``1.0`` sono validi solo per la modalità bilineare e possono essere utilizzati per migliorare la qualità del rendering 3D a un costo elevato in termini di prestazioni (sovracampionamento). Vedi anche :ref:`ProjectSettings.rendering/anti_aliasing/quality/msaa_3d<class_ProjectSettings_property_rendering/anti_aliasing/quality/msaa_3d>` per l'antialiasing multi-campione, che è notevolmente più economico per le prestazioni, ma smussa solo i bordi dei poligoni.
Quando si utilizza l'upscaling FSR, AMD consiglia di esporre i seguenti valori come opzioni preimpostate agli utenti "Ultra Qualità: 0.77", "Qualità: 0.67", "Bilanciato: 0.59", "Prestazioni: 0.5" anziché esporre l'intera scala.
Per controllare questa proprietà nella viewport radice, cambia l'impostazione del progetto :ref:`ProjectSettings.rendering/scaling_3d/scale<class_ProjectSettings_property_rendering/scaling_3d/scale>`.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_screen_space_aa:
.. rst-class:: classref-property
:ref:`ScreenSpaceAA<enum_Viewport_ScreenSpaceAA>` **screen_space_aa** = ``0`` :ref:`🔗<class_Viewport_property_screen_space_aa>`
.. rst-class:: classref-property-setget
- |void| **set_screen_space_aa**\ (\ value\: :ref:`ScreenSpaceAA<enum_Viewport_ScreenSpaceAA>`\ )
- :ref:`ScreenSpaceAA<enum_Viewport_ScreenSpaceAA>` **get_screen_space_aa**\ (\ )
Imposta il metodo di antialiasing screen-space utilizzato. L'antialiasing screen-space funziona sfocando selettivamente i bordi in uno shader post-process. Si differenzia da MSAA che prende multipli campioni di copertura durante il rendering degli oggetti. I metodi di AA screen-space sono in genere più veloci di MSAA e smussano l'aliasing speculare, ma tendono a far apparire le scene sfocate.
Vedi anche :ref:`ProjectSettings.rendering/anti_aliasing/quality/screen_space_aa<class_ProjectSettings_property_rendering/anti_aliasing/quality/screen_space_aa>` e :ref:`RenderingServer.viewport_set_screen_space_aa()<class_RenderingServer_method_viewport_set_screen_space_aa>`.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_sdf_oversize:
.. rst-class:: classref-property
:ref:`SDFOversize<enum_Viewport_SDFOversize>` **sdf_oversize** = ``1`` :ref:`🔗<class_Viewport_property_sdf_oversize>`
.. rst-class:: classref-property-setget
- |void| **set_sdf_oversize**\ (\ value\: :ref:`SDFOversize<enum_Viewport_SDFOversize>`\ )
- :ref:`SDFOversize<enum_Viewport_SDFOversize>` **get_sdf_oversize**\ (\ )
Controlla la quantità di dimensioni della finestra originale che deve essere coperta dal campo della distanza con segno 2D. Questo SDF può essere campionato negli shader :ref:`CanvasItem<class_CanvasItem>` ed è anche usato per la collisione di :ref:`GPUParticles2D<class_GPUParticles2D>`. Valori più alti consentono che le porzioni di occlusioni situati all'esterno della finestra siano comunque prese in considerazione nel campo di distanza con segno generato, a scapito delle prestazioni. Se noti particelle che cadono attraverso i :ref:`LightOccluder2D<class_LightOccluder2D>` quando gli occlusori abbandonano la viewport, aumenta questa impostazione.
La percentuale è aggiunta su ogni asse e su entrambi i lati. Ad esempio, con il valore predefinito :ref:`SDF_OVERSIZE_120_PERCENT<class_Viewport_constant_SDF_OVERSIZE_120_PERCENT>`, il campo di distanza con segno coprirà il 20% della dimensione della viewport all'esterno della viewport su ogni lato (in alto, a destra, in basso, a sinistra).
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_sdf_scale:
.. rst-class:: classref-property
:ref:`SDFScale<enum_Viewport_SDFScale>` **sdf_scale** = ``1`` :ref:`🔗<class_Viewport_property_sdf_scale>`
.. rst-class:: classref-property-setget
- |void| **set_sdf_scale**\ (\ value\: :ref:`SDFScale<enum_Viewport_SDFScale>`\ )
- :ref:`SDFScale<enum_Viewport_SDFScale>` **get_sdf_scale**\ (\ )
La scala di risoluzione da usare per il campo di distanza con segno 2D. Valori più alti portano a un campo di distanza con segno più preciso e più stabile mentre la telecamera si muove, a scapito delle prestazioni.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_snap_2d_transforms_to_pixel:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **snap_2d_transforms_to_pixel** = ``false`` :ref:`🔗<class_Viewport_property_snap_2d_transforms_to_pixel>`
.. rst-class:: classref-property-setget
- |void| **set_snap_2d_transforms_to_pixel**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_snap_2d_transforms_to_pixel_enabled**\ (\ )
Se ``true``, i nodi :ref:`CanvasItem<class_CanvasItem>` si allineano perfettamente ai pixel. La loro posizione può ancora essere in mezzo ai pixel, ma i decimali non avranno effetto. Ciò può portare a un aspetto più nitido a scapito di un movimento meno fluido, specialmente quando è abilitato la smussatura di :ref:`Camera2D<class_Camera2D>`.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_snap_2d_vertices_to_pixel:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **snap_2d_vertices_to_pixel** = ``false`` :ref:`🔗<class_Viewport_property_snap_2d_vertices_to_pixel>`
.. rst-class:: classref-property-setget
- |void| **set_snap_2d_vertices_to_pixel**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_snap_2d_vertices_to_pixel_enabled**\ (\ )
Se ``true``, i vertici dei nodi :ref:`CanvasItem<class_CanvasItem>` si allineano perfettamente ai pixel. Influisce solo sulle posizioni finali dei vertici, non sulle trasformazioni. Ciò può portare a un aspetto più nitido a scapito di un movimento meno fluido, specialmente quando è abilitato la smussatura di :ref:`Camera2D<class_Camera2D>`.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_texture_mipmap_bias:
.. rst-class:: classref-property
:ref:`float<class_float>` **texture_mipmap_bias** = ``0.0`` :ref:`🔗<class_Viewport_property_texture_mipmap_bias>`
.. rst-class:: classref-property-setget
- |void| **set_texture_mipmap_bias**\ (\ value\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_texture_mipmap_bias**\ (\ )
Influisce sulla nitidezza finale della texture leggendo da una mipmap inferiore o superiore (chiamata anche "texture LOD bias"). I valori negativi rendono le texture mipmap più nitide ma più granulose se viste da lontano, mentre i valori positivi rendono le texture mipmap più sfocate (anche da vicino).
L'attivazione dell'antialiasing temporale (:ref:`use_taa<class_Viewport_property_use_taa>`) applicherà automaticamente un offset di ``-0,5`` a questo valore, mentre l'attivazione di FXAA (:ref:`screen_space_aa<class_Viewport_property_screen_space_aa>`) applicherà automaticamente un offset di ``-0,25`` a questo valore. Se TAA e FXAA sono abilitati allo stesso tempo, a questo valore viene applicato un offset di ``-0,75``.
\ **Nota:** Se :ref:`scaling_3d_scale<class_Viewport_property_scaling_3d_scale>` è inferiore a ``1.0`` (esclusivo), :ref:`texture_mipmap_bias<class_Viewport_property_texture_mipmap_bias>` viene utilizzato per regolare il bias mipmap automatico calcolato internamente in base al fattore di scala. La formula per questo è ``log2(scaling_3d_scale) + mipmap_bias``.
Per controllare questa proprietà nella viewport radice, cambia l'impostazione del progetto :ref:`ProjectSettings.rendering/textures/default_filters/texture_mipmap_bias<class_ProjectSettings_property_rendering/textures/default_filters/texture_mipmap_bias>`.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_transparent_bg:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **transparent_bg** = ``false`` :ref:`🔗<class_Viewport_property_transparent_bg>`
.. rst-class:: classref-property-setget
- |void| **set_transparent_background**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **has_transparent_background**\ (\ )
If ``true``, the viewport should render its background as transparent.
\ **Note:** Due to technical limitations, certain rendering features are disabled when a viewport has a transparent background. This currently applies to screen-space reflections, subsurface scattering, and depth of field.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_use_debanding:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **use_debanding** = ``false`` :ref:`🔗<class_Viewport_property_use_debanding>`
.. rst-class:: classref-property-setget
- |void| **set_use_debanding**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_using_debanding**\ (\ )
When using the Mobile or Forward+ renderers, set :ref:`use_debanding<class_Viewport_property_use_debanding>` to enable or disable the debanding feature of this **Viewport**. If :ref:`use_hdr_2d<class_Viewport_property_use_hdr_2d>` is ``false``, 2D rendering is *not* affected by debanding unless the :ref:`Environment.background_mode<class_Environment_property_background_mode>` is :ref:`Environment.BG_CANVAS<class_Environment_constant_BG_CANVAS>`. If :ref:`use_hdr_2d<class_Viewport_property_use_hdr_2d>` is ``true``, debanding will only be applied if this is the root **Viewport** and will affect all 2D and 3D rendering, including canvas items.
\ :ref:`use_debanding<class_Viewport_property_use_debanding>` has no effect when using the Compatibility rendering method. The Mobile renderer can also use material debanding, which can be set with :ref:`RenderingServer.material_set_use_debanding()<class_RenderingServer_method_material_set_use_debanding>` or configured with :ref:`ProjectSettings.rendering/anti_aliasing/quality/use_debanding<class_ProjectSettings_property_rendering/anti_aliasing/quality/use_debanding>`.
See also :ref:`ProjectSettings.rendering/anti_aliasing/quality/use_debanding<class_ProjectSettings_property_rendering/anti_aliasing/quality/use_debanding>`, :ref:`RenderingServer.material_set_use_debanding()<class_RenderingServer_method_material_set_use_debanding>`, and :ref:`RenderingServer.viewport_set_use_debanding()<class_RenderingServer_method_viewport_set_use_debanding>`.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_use_hdr_2d:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **use_hdr_2d** = ``false`` :ref:`🔗<class_Viewport_property_use_hdr_2d>`
.. rst-class:: classref-property-setget
- |void| **set_use_hdr_2d**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_using_hdr_2d**\ (\ )
If ``true``, 2D rendering will use a high dynamic range (HDR) ``RGBA16`` format framebuffer. Additionally, 2D rendering will be performed on linear values and will be converted using the appropriate transfer function immediately before blitting to the screen (if the Viewport is attached to the screen).
Practically speaking, this means that the end result of the Viewport will not be clamped to the ``0-1`` range and can be used in 3D rendering without color encoding adjustments. This allows 2D rendering to take advantage of effects requiring high dynamic range (e.g. 2D glow) as well as substantially improves the appearance of effects requiring highly detailed gradients.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_use_occlusion_culling:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **use_occlusion_culling** = ``false`` :ref:`🔗<class_Viewport_property_use_occlusion_culling>`
.. rst-class:: classref-property-setget
- |void| **set_use_occlusion_culling**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_using_occlusion_culling**\ (\ )
Se ``true``, i nodi :ref:`OccluderInstance3D<class_OccluderInstance3D>` saranno utilizzabili per l'occlusion culling in 3D per questa viewport. Per la viewport radice, :ref:`ProjectSettings.rendering/occlusion_culling/use_occlusion_culling<class_ProjectSettings_property_rendering/occlusion_culling/use_occlusion_culling>` deve essere impostato su ``true``.
\ **Nota:** L'abilitazione dell'occlusion culling ha un costo sulla CPU. Abilita l'occlusion culling solo se hai effettivamente intenzione di usarlo. Grandi scene aperte con pochi o nessun oggetto che blocca la vista in genere non usufruiranno dall'occlusion culling. Le grandi scene aperte in genere usufruiranno da mesh LOD e intervalli di visibilità (:ref:`GeometryInstance3D.visibility_range_begin<class_GeometryInstance3D_property_visibility_range_begin>` e :ref:`GeometryInstance3D.visibility_range_end<class_GeometryInstance3D_property_visibility_range_end>`) rispetto all'occlusion culling.
\ **Nota:** A causa di vincoli di memoria, l'occlusion culling non è supportato per impostazione predefinita nei modelli di esportazione Web. Può essere abilitato compilando modelli di esportazione Web personalizzati con ``module_raycast_enabled=yes``.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_use_taa:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **use_taa** = ``false`` :ref:`🔗<class_Viewport_property_use_taa>`
.. rst-class:: classref-property-setget
- |void| **set_use_taa**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_using_taa**\ (\ )
Abilita l'antialiasing temporale per questa viewport. Il TAA funziona tremolando la telecamera e accumulando le immagini degli ultimi fotogrammi renderizzati, il rendering del vettore di movimento è utilizzato per tenere conto del movimento della telecamera e degli oggetti.
\ **Nota:** L'implementazione non è ancora completa. Alcune istanze visive come particelle e mesh con skin potrebbero mostrare artefatti di ghosting.
Vedi anche :ref:`ProjectSettings.rendering/anti_aliasing/quality/use_taa<class_ProjectSettings_property_rendering/anti_aliasing/quality/use_taa>` e :ref:`RenderingServer.viewport_set_use_taa()<class_RenderingServer_method_viewport_set_use_taa>`.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_use_xr:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **use_xr** = ``false`` :ref:`🔗<class_Viewport_property_use_xr>`
.. rst-class:: classref-property-setget
- |void| **set_use_xr**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_using_xr**\ (\ )
Se ``true``, la viewport utilizzerà l'interfaccia XR primaria per renderizzare l'output di XR. Quando applicabile, ciò può generare un'immagine stereoscopica e il rendering risultante sarà trasmesso a un visore.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_vrs_mode:
.. rst-class:: classref-property
:ref:`VRSMode<enum_Viewport_VRSMode>` **vrs_mode** = ``0`` :ref:`🔗<class_Viewport_property_vrs_mode>`
.. rst-class:: classref-property-setget
- |void| **set_vrs_mode**\ (\ value\: :ref:`VRSMode<enum_Viewport_VRSMode>`\ )
- :ref:`VRSMode<enum_Viewport_VRSMode>` **get_vrs_mode**\ (\ )
La modalità Variable Rate Shading (VRS) utilizzata per questa viewport. Nota, se l'hardware non supporta VRS, questa proprietà è ignorata.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_vrs_texture:
.. rst-class:: classref-property
:ref:`Texture2D<class_Texture2D>` **vrs_texture** :ref:`🔗<class_Viewport_property_vrs_texture>`
.. rst-class:: classref-property-setget
- |void| **set_vrs_texture**\ (\ value\: :ref:`Texture2D<class_Texture2D>`\ )
- :ref:`Texture2D<class_Texture2D>` **get_vrs_texture**\ (\ )
La texture da usare quando :ref:`vrs_mode<class_Viewport_property_vrs_mode>` è impostato su :ref:`VRS_TEXTURE<class_Viewport_constant_VRS_TEXTURE>`.
La texture *deve* usare un formato di compressione senza perdite, in modo che i colori possano essere abbinati con precisione. Le seguenti densità di VRS sono mappate su vari colori, con i colori più brillanti che rappresentano un livello inferiore di precisione di ombreggiatura:
.. code:: text
- 1×1 = rgb(0, 0, 0) - #000000
- 1×2 = rgb(0, 85, 0) - #005500
- 2×1 = rgb(85, 0, 0) - #550000
- 2×2 = rgb(85, 85, 0) - #555500
- 2×4 = rgb(85, 170, 0) - #55aa00
- 4×2 = rgb(170, 85, 0) - #aa5500
- 4×4 = rgb(170, 170, 0) - #aaaa00
- 4×8 = rgb(170, 255, 0) - #aaff00 - Non supportato sulla maggior parte degli hardware
- 8×4 = rgb(255, 170, 0) - #ffaa00 - Non supportato sulla maggior parte degli hardware
- 8×8 = rgb(255, 255, 0) - #ffff00 - Non supportato sulla maggior parte degli hardware
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_vrs_update_mode:
.. rst-class:: classref-property
:ref:`VRSUpdateMode<enum_Viewport_VRSUpdateMode>` **vrs_update_mode** = ``1`` :ref:`🔗<class_Viewport_property_vrs_update_mode>`
.. rst-class:: classref-property-setget
- |void| **set_vrs_update_mode**\ (\ value\: :ref:`VRSUpdateMode<enum_Viewport_VRSUpdateMode>`\ )
- :ref:`VRSUpdateMode<enum_Viewport_VRSUpdateMode>` **get_vrs_update_mode**\ (\ )
Imposta la modalità di aggiornamento per il Variable Rate Shading (VRS) per la viewport. Il VRS richiede che la texture di input sia convertita nel formato utilizzabile dal metodo VRS supportato dall'hardware. La modalità di aggiornamento definisce la frequenza con cui ciò avviene. Se la GPU non supporta VRS o VRS non è abilitato, questa proprietà è ignorata.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_world_2d:
.. rst-class:: classref-property
:ref:`World2D<class_World2D>` **world_2d** :ref:`🔗<class_Viewport_property_world_2d>`
.. rst-class:: classref-property-setget
- |void| **set_world_2d**\ (\ value\: :ref:`World2D<class_World2D>`\ )
- :ref:`World2D<class_World2D>` **get_world_2d**\ (\ )
Il :ref:`World2D<class_World2D>` personalizzato che può essere utilizzato come sorgente dell'ambiente 2D.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_world_3d:
.. rst-class:: classref-property
:ref:`World3D<class_World3D>` **world_3d** :ref:`🔗<class_Viewport_property_world_3d>`
.. rst-class:: classref-property-setget
- |void| **set_world_3d**\ (\ value\: :ref:`World3D<class_World3D>`\ )
- :ref:`World3D<class_World3D>` **get_world_3d**\ (\ )
Il :ref:`World3D<class_World3D>` personalizzato che può essere utilizzato come sorgente dell'ambiente 3D.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descrizioni dei metodi
--------------------------------------------
.. _class_Viewport_method_find_world_2d:
.. rst-class:: classref-method
:ref:`World2D<class_World2D>` **find_world_2d**\ (\ ) |const| :ref:`🔗<class_Viewport_method_find_world_2d>`
Restituisce il primo :ref:`World2D<class_World2D>` valido per questa viewport, cercando la proprietà :ref:`world_2d<class_Viewport_property_world_2d>` di se stessa e di qualsiasi antenato della Viewport.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_find_world_3d:
.. rst-class:: classref-method
:ref:`World3D<class_World3D>` **find_world_3d**\ (\ ) |const| :ref:`🔗<class_Viewport_method_find_world_3d>`
Restituisce il primo :ref:`World3D<class_World3D>` valido per questa viewport, cercando la proprietà :ref:`world_3d<class_Viewport_property_world_3d>` di se stessa e di qualsiasi antenato della Viewport.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_get_audio_listener_2d:
.. rst-class:: classref-method
:ref:`AudioListener2D<class_AudioListener2D>` **get_audio_listener_2d**\ (\ ) |const| :ref:`🔗<class_Viewport_method_get_audio_listener_2d>`
Restituisce l'ascoltatore audio 2D attualmente attivo. Restituisce ``null`` se non ci sono ascoltatori audio 2D, nel qual caso la telecamera 2D attiva sarà trattata come ascoltatore.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_get_audio_listener_3d:
.. rst-class:: classref-method
:ref:`AudioListener3D<class_AudioListener3D>` **get_audio_listener_3d**\ (\ ) |const| :ref:`🔗<class_Viewport_method_get_audio_listener_3d>`
Restituisce l'ascoltatore audio 3D attualmente attivo. Restituisce ``null`` se non ci sono ascoltatori audio 3D, nel qual caso la telecamera 3D attiva sarà trattata come ascoltatore.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_get_camera_2d:
.. rst-class:: classref-method
:ref:`Camera2D<class_Camera2D>` **get_camera_2d**\ (\ ) |const| :ref:`🔗<class_Viewport_method_get_camera_2d>`
Returns the currently active 2D camera. Returns ``null`` if there are no active cameras.
\ **Note:** If called while the *Camera Override* system is active in editor, this will return the internally managed override camera. It is therefore advised to avoid caching the return value, or to check that the cached value is still a valid instance and is the current camera before use. See :ref:`@GlobalScope.is_instance_valid()<class_@GlobalScope_method_is_instance_valid>` and :ref:`Camera2D.is_current()<class_Camera2D_method_is_current>`.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_get_camera_3d:
.. rst-class:: classref-method
:ref:`Camera3D<class_Camera3D>` **get_camera_3d**\ (\ ) |const| :ref:`🔗<class_Viewport_method_get_camera_3d>`
Returns the currently active 3D camera. Returns ``null`` if there are no active cameras.
\ **Note:** If called while the *Camera Override* system is active in editor, this will return the internally managed override camera. It is therefore advised to avoid caching the return value, or to check that the cached value is a valid instance and is the current camera before use. See :ref:`@GlobalScope.is_instance_valid()<class_@GlobalScope_method_is_instance_valid>` and :ref:`Camera3D.current<class_Camera3D_property_current>`.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_get_canvas_cull_mask_bit:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **get_canvas_cull_mask_bit**\ (\ layer\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_Viewport_method_get_canvas_cull_mask_bit>`
Restituisce un singolo bit sulla maschera dello strato di rendering.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_get_embedded_subwindows:
.. rst-class:: classref-method
:ref:`Array<class_Array>`\[:ref:`Window<class_Window>`\] **get_embedded_subwindows**\ (\ ) |const| :ref:`🔗<class_Viewport_method_get_embedded_subwindows>`
Restituisce un'elenco delle finestre (:ref:`Window<class_Window>`) incorporate visibili all'interno della viewport.
\ **Nota:** Le :ref:`Window<class_Window>` all'interno di altre viewport non saranno elencate.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_get_final_transform:
.. rst-class:: classref-method
:ref:`Transform2D<class_Transform2D>` **get_final_transform**\ (\ ) |const| :ref:`🔗<class_Viewport_method_get_final_transform>`
Restituisce la trasformazione dal sistema di coordinate della viewport al sistema di coordinate dell'incorporatore.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_get_mouse_position:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **get_mouse_position**\ (\ ) |const| :ref:`🔗<class_Viewport_method_get_mouse_position>`
Restituisce la posizione del mouse in questa **Viewport** nel sistema di coordinate di questa **Viewport**.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_get_oversampling:
.. rst-class:: classref-method
:ref:`float<class_float>` **get_oversampling**\ (\ ) |const| :ref:`🔗<class_Viewport_method_get_oversampling>`
Restituisce il fattore di sovracampionamento della viewport.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_get_positional_shadow_atlas_quadrant_subdiv:
.. rst-class:: classref-method
:ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **get_positional_shadow_atlas_quadrant_subdiv**\ (\ quadrant\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_Viewport_method_get_positional_shadow_atlas_quadrant_subdiv>`
Restituisce la suddivisione di quadrante delle ombre posizionali del quadrante specificato.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_get_render_info:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_render_info**\ (\ type\: :ref:`RenderInfoType<enum_Viewport_RenderInfoType>`, info\: :ref:`RenderInfo<enum_Viewport_RenderInfo>`\ ) :ref:`🔗<class_Viewport_method_get_render_info>`
Restituisce le statistiche di rendering del tipo specificato.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_get_screen_transform:
.. rst-class:: classref-method
:ref:`Transform2D<class_Transform2D>` **get_screen_transform**\ (\ ) |const| :ref:`🔗<class_Viewport_method_get_screen_transform>`
Restituisce la trasformazione dalle coordinate della Viewport alle coordinate dello schermo della finestra di gestione finestre che la contiene.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_get_stretch_transform:
.. rst-class:: classref-method
:ref:`Transform2D<class_Transform2D>` **get_stretch_transform**\ (\ ) |const| :ref:`🔗<class_Viewport_method_get_stretch_transform>`
Restituisce la trasformazione di allungamento 2D calcolata automaticamente, tenendo conto delle impostazioni di allungamento della **Viewport**. Il valore finale è moltiplicato per :ref:`Window.content_scale_factor<class_Window_property_content_scale_factor>`, ma solo per la viewport radice. Se questo metodo viene chiamato su un :ref:`SubViewport<class_SubViewport>` (ad esempio, in un albero di scene con :ref:`SubViewportContainer<class_SubViewportContainer>` e :ref:`SubViewport<class_SubViewport>`), il fattore di scala della finestra radice non verrà applicato. Utilizzando :ref:`Transform2D.get_scale()<class_Transform2D_method_get_scale>` sul valore restituito, questo può essere utilizzato per compensare il ridimensionamento quando si aumenta lo zoom di un nodo :ref:`Camera2D<class_Camera2D>` o per rimpicciolire un :ref:`TextureRect<class_TextureRect>` in modo che sia pixel-perfect a prescindere dal fattore di scala calcolato automaticamente.
\ **Nota:** A causa del funzionamento del ridimensionamento dei pixel, la scala X e Y della trasformazione restituita potrebbe differire leggermente, anche quando :ref:`Window.content_scale_aspect<class_Window_property_content_scale_aspect>` è impostato su una modalità che preserva le proporzioni dei pixel. Se :ref:`Window.content_scale_aspect<class_Window_property_content_scale_aspect>` è :ref:`Window.CONTENT_SCALE_ASPECT_IGNORE<class_Window_constant_CONTENT_SCALE_ASPECT_IGNORE>`, la scala X e Y potrebbero differire *significativamente*.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_get_texture:
.. rst-class:: classref-method
:ref:`ViewportTexture<class_ViewportTexture>` **get_texture**\ (\ ) |const| :ref:`🔗<class_Viewport_method_get_texture>`
Returns the viewport's texture.
\ **Note:** When trying to store the current texture (e.g. in a file), it might be completely black or outdated if used too early, especially when used in e.g. :ref:`Node._ready()<class_Node_private_method__ready>`. To make sure the texture you get is correct, you can await :ref:`RenderingServer.frame_post_draw<class_RenderingServer_signal_frame_post_draw>` signal.
.. tabs::
.. code-tab:: gdscript
func _ready():
await RenderingServer.frame_post_draw
$Viewport.get_texture().get_image().save_png("user://Screenshot.png")
.. code-tab:: csharp
public async override void _Ready()
{
await ToSignal(RenderingServer.Singleton, RenderingServer.SignalName.FramePostDraw);
var viewport = GetNode<Viewport>("Viewport");
viewport.GetTexture().GetImage().SavePng("user://Screenshot.png");
}
\ **Note:** When :ref:`use_hdr_2d<class_Viewport_property_use_hdr_2d>` is ``true`` the returned texture will be an HDR image using linear encoding.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_get_viewport_rid:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **get_viewport_rid**\ (\ ) |const| :ref:`🔗<class_Viewport_method_get_viewport_rid>`
Restituisce il :ref:`RID<class_RID>` della viewport dal :ref:`RenderingServer<class_RenderingServer>`.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_get_visible_rect:
.. rst-class:: classref-method
:ref:`Rect2<class_Rect2>` **get_visible_rect**\ (\ ) |const| :ref:`🔗<class_Viewport_method_get_visible_rect>`
Restituisce il rettangolo visibile nelle coordinate globali dello schermo.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_gui_cancel_drag:
.. rst-class:: classref-method
|void| **gui_cancel_drag**\ (\ ) :ref:`🔗<class_Viewport_method_gui_cancel_drag>`
Cancella l'operazione di trascinamento che è stata cominciata in precedenza attraverso :ref:`Control._get_drag_data()<class_Control_private_method__get_drag_data>` o forzata con :ref:`Control.force_drag()<class_Control_method_force_drag>`.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_gui_get_drag_data:
.. rst-class:: classref-method
:ref:`Variant<class_Variant>` **gui_get_drag_data**\ (\ ) |const| :ref:`🔗<class_Viewport_method_gui_get_drag_data>`
Restituisce i dati di trascinamento dalla GUI, restituiti in precedenza da :ref:`Control._get_drag_data()<class_Control_private_method__get_drag_data>`.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_gui_get_drag_description:
.. rst-class:: classref-method
:ref:`String<class_String>` **gui_get_drag_description**\ (\ ) |const| :ref:`🔗<class_Viewport_method_gui_get_drag_description>`
Returns the human-readable description of the drag data, used for assistive apps.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_gui_get_focus_owner:
.. rst-class:: classref-method
:ref:`Control<class_Control>` **gui_get_focus_owner**\ (\ ) |const| :ref:`🔗<class_Viewport_method_gui_get_focus_owner>`
Restituisce il :ref:`Control<class_Control>` attualmente focalizzato all'interno di questa viewport. Se nessun :ref:`Control<class_Control>` ha il focus, restituisce ``null``.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_gui_get_hovered_control:
.. rst-class:: classref-method
:ref:`Control<class_Control>` **gui_get_hovered_control**\ (\ ) |const| :ref:`🔗<class_Viewport_method_gui_get_hovered_control>`
Restituisce il :ref:`Control<class_Control>` su cui si trova attualmente il mouse in questa viewport. Se nessun :ref:`Control<class_Control>` ha il cursore, restituisce ``null``.
In genere il nodo :ref:`Control<class_Control>` foglia o il livello più profondo del sottoalbero che è influenzato dal passaggio del mouse. Questo è molto utile se utilizzato insieme a :ref:`Node.is_ancestor_of()<class_Node_method_is_ancestor_of>` per scoprire se il mouse si trova all'interno di un albero di controlli.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_gui_is_drag_successful:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **gui_is_drag_successful**\ (\ ) |const| :ref:`🔗<class_Viewport_method_gui_is_drag_successful>`
Restituisce ``true`` se l'operazione di trascinamento ha successo.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_gui_is_dragging:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **gui_is_dragging**\ (\ ) |const| :ref:`🔗<class_Viewport_method_gui_is_dragging>`
Restituisce ``true`` se la viewport sta attualmente effettuando un'operazione di trascinamento e dove un'azione di rilascio potrebbe occorrere in questa viewport.
Alternativa a :ref:`Node.NOTIFICATION_DRAG_BEGIN<class_Node_constant_NOTIFICATION_DRAG_BEGIN>` e :ref:`Node.NOTIFICATION_DRAG_END<class_Node_constant_NOTIFICATION_DRAG_END>` quando si preferisce recuperare direttamente il valore.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_gui_release_focus:
.. rst-class:: classref-method
|void| **gui_release_focus**\ (\ ) :ref:`🔗<class_Viewport_method_gui_release_focus>`
Rimuove il focus dal :ref:`Control<class_Control>` attualmente focalizzato all'interno di questa viewport. Se nessun :ref:`Control<class_Control>` ha il focus, non fa nulla.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_gui_set_drag_description:
.. rst-class:: classref-method
|void| **gui_set_drag_description**\ (\ description\: :ref:`String<class_String>`\ ) :ref:`🔗<class_Viewport_method_gui_set_drag_description>`
Sets the human-readable description of the drag data to ``description``, used for assistive apps.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_is_input_handled:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_input_handled**\ (\ ) |const| :ref:`🔗<class_Viewport_method_is_input_handled>`
Restituisce se l':ref:`InputEvent<class_InputEvent>` attuale è stato gestito. Gli eventi di input non sono gestiti finché non viene chiamato :ref:`set_input_as_handled()<class_Viewport_method_set_input_as_handled>` durante il ciclo di vita di un :ref:`InputEvent<class_InputEvent>`.
Questo viene solitamente fatto come parte di metodi di gestione dell'input come :ref:`Node._input()<class_Node_private_method__input>`, :ref:`Control._gui_input()<class_Control_private_method__gui_input>` o altri, così come nei corrispondenti segnali.
Se :ref:`handle_input_locally<class_Viewport_property_handle_input_locally>` è impostato su ``false``, questo metodo proverà a trovare la prima viewport genitore impostata per gestire l'input localmente e restituirà invece il suo valore per :ref:`is_input_handled()<class_Viewport_method_is_input_handled>`.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_notify_mouse_entered:
.. rst-class:: classref-method
|void| **notify_mouse_entered**\ (\ ) :ref:`🔗<class_Viewport_method_notify_mouse_entered>`
Informa la Viewport che il mouse è entrato nella sua area. Usa questa funzione prima di inviare un :ref:`InputEventMouseButton<class_InputEventMouseButton>` o :ref:`InputEventMouseMotion<class_InputEventMouseMotion>` alla **Viewport** con :ref:`push_input()<class_Viewport_method_push_input>`. Vedi anche :ref:`notify_mouse_exited()<class_Viewport_method_notify_mouse_exited>`.
\ **Nota:** Nella maggior parte dei casi, non è necessario chiamare questa funzione perché i nodi :ref:`SubViewport<class_SubViewport>` che sono figli di :ref:`SubViewportContainer<class_SubViewportContainer>` vengono notificati automaticamente. Ciò è necessario solo quando si interagisce con i viewport in modi non predefiniti, ad esempio come texture in :ref:`TextureRect<class_TextureRect>` o con un :ref:`Area3D<class_Area3D>` che inoltra gli eventi di input.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_notify_mouse_exited:
.. rst-class:: classref-method
|void| **notify_mouse_exited**\ (\ ) :ref:`🔗<class_Viewport_method_notify_mouse_exited>`
Informa la Viewport che il mouse è uscito dalla sua area. Usa questa funzione quando il nodo che visualizza la viewport nota che il mouse ha lasciato l'area della viewport visualizzata. Vedi anche :ref:`notify_mouse_entered()<class_Viewport_method_notify_mouse_entered>`.
\ **Nota:** Nella maggior parte dei casi, non è necessario chiamare questa funzione perché i nodi :ref:`SubViewport<class_SubViewport>` che sono figli di :ref:`SubViewportContainer<class_SubViewportContainer>` vengono notificati automaticamente. Ciò è necessario solo quando si interagisce con i viewport in modi non predefiniti, ad esempio come texture in :ref:`TextureRect<class_TextureRect>` o con un :ref:`Area3D<class_Area3D>` che inoltra gli eventi di input.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_push_input:
.. rst-class:: classref-method
|void| **push_input**\ (\ event\: :ref:`InputEvent<class_InputEvent>`, in_local_coords\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_Viewport_method_push_input>`
Attiva l'evento ``event`` in questa **Viewport**. Può essere utilizzato per passare un :ref:`InputEvent<class_InputEvent>` tra viewport o per applicare localmente gli input inviati tramite la rete o salvati in un file.
Se ``in_local_coords`` è ``false``, la posizione dell'evento è nelle coordinate dell'incorporatore e sarà convertita in coordinate della viewport. Se ``in_local_coords`` è ``true``, la posizione dell'evento è nelle coordinate della viewport.
Sebbene questo metodo svolga uno scopo simile a :ref:`Input.parse_input_event()<class_Input_method_parse_input_event>`, non rimappa l'evento ``event`` in base alle impostazioni del progetto come :ref:`ProjectSettings.input_devices/pointing/emulate_touch_from_mouse<class_ProjectSettings_property_input_devices/pointing/emulate_touch_from_mouse>`.
La chiamata a questo metodo propagherà le chiamate ai nodi figlio per i seguenti metodi nell'ordine indicato:
- :ref:`Node._input()<class_Node_private_method__input>`\
- :ref:`Control._gui_input()<class_Control_private_method__gui_input>` per i nodi :ref:`Control<class_Control>`\
- :ref:`Node._shortcut_input()<class_Node_private_method__shortcut_input>`\
- :ref:`Node._unhandled_key_input()<class_Node_private_method__unhandled_key_input>`\
- :ref:`Node._unhandled_input()<class_Node_private_method__unhandled_input>`\
Se un metodo precedente contrassegna l'input come gestito tramite :ref:`set_input_as_handled()<class_Viewport_method_set_input_as_handled>`, nessun metodo successivo in questo elenco verrà chiamato.
Se nessuno dei metodi gestisce l'evento e :ref:`physics_object_picking<class_Viewport_property_physics_object_picking>` è ``true``, l'evento è utilizzato per la selezione degli oggetti di fisica.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_push_text_input:
.. rst-class:: classref-method
|void| **push_text_input**\ (\ text\: :ref:`String<class_String>`\ ) :ref:`🔗<class_Viewport_method_push_text_input>`
Metodo di supporto che richiama il metodo ``set_text()`` sul :ref:`Control<class_Control>` attualmente attivo, a condizione che sia definito (ad esempio se il controllo attivo è :ref:`Button<class_Button>` o :ref:`LineEdit<class_LineEdit>`).
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_push_unhandled_input:
.. rst-class:: classref-method
|void| **push_unhandled_input**\ (\ event\: :ref:`InputEvent<class_InputEvent>`, in_local_coords\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_Viewport_method_push_unhandled_input>`
**Deprecato:** Use :ref:`push_input()<class_Viewport_method_push_input>` instead.
Attiva l'evento ``event`` in questa **Viewport**. Può essere utilizzato per passare un :ref:`InputEvent<class_InputEvent>` tra viewport o per applicare localmente gli input inviati tramite la rete o salvati in un file.
Se ``in_local_coords`` è ``false``, la posizione dell'evento è nelle coordinate dell'incorporatore e sarà convertita in coordinate della viewport. Se ``in_local_coords`` è ``true``, la posizione dell'evento è nelle coordinate della viewport.
La chiamata a questo metodo propagherà le chiamate ai nodi figlio per i seguenti metodi nell'ordine indicato:
- :ref:`Node._shortcut_input()<class_Node_private_method__shortcut_input>`\
- :ref:`Node._unhandled_key_input()<class_Node_private_method__unhandled_key_input>`\
- :ref:`Node._unhandled_input()<class_Node_private_method__unhandled_input>`\
Se un metodo precedente contrassegna l'input come gestito tramite :ref:`set_input_as_handled()<class_Viewport_method_set_input_as_handled>`, nessun metodo successivo in questo elenco verrà chiamato.
Se nessuno dei metodi gestisce l'evento e :ref:`physics_object_picking<class_Viewport_property_physics_object_picking>` è ``true``, l'evento è utilizzato per la selezione degli oggetti di fisica.
\ **Nota:** Questo metodo non propaga gli eventi di input ai :ref:`Window<class_Window>` o :ref:`SubViewport<class_SubViewport>` incorporati.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_set_canvas_cull_mask_bit:
.. rst-class:: classref-method
|void| **set_canvas_cull_mask_bit**\ (\ layer\: :ref:`int<class_int>`, enable\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_Viewport_method_set_canvas_cull_mask_bit>`
Imposta/cancella singoli bit sulla maschera dello strato di rendering. Ciò semplifica la modifica degli strati di questa **Viewport**.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_set_input_as_handled:
.. rst-class:: classref-method
|void| **set_input_as_handled**\ (\ ) :ref:`🔗<class_Viewport_method_set_input_as_handled>`
Stops the input from propagating further up the :ref:`SceneTree<class_SceneTree>`.
\ **Note:** This does not affect the methods in :ref:`Input<class_Input>`, only the way events are propagated.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_set_positional_shadow_atlas_quadrant_subdiv:
.. rst-class:: classref-method
|void| **set_positional_shadow_atlas_quadrant_subdiv**\ (\ quadrant\: :ref:`int<class_int>`, subdiv\: :ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>`\ ) :ref:`🔗<class_Viewport_method_set_positional_shadow_atlas_quadrant_subdiv>`
Imposta il numero di suddivisioni da usare nel quadrante specificato. Un numero maggiore di suddivisioni consente di avere più ombre nella scena contemporaneamente, ma ne riduce la qualità. Una buona pratica è quella di avere quadranti con un numero variabile di suddivisioni e di avere il minor numero possibile di suddivisioni.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_update_mouse_cursor_state:
.. rst-class:: classref-method
|void| **update_mouse_cursor_state**\ (\ ) :ref:`🔗<class_Viewport_method_update_mouse_cursor_state>`
Forza l'aggiornamento immediato del display in base alla posizione attuale del cursore del mouse. Ciò include l'aggiornamento della forma del cursore del mouse, l'invio dei segnali necessari :ref:`Control.mouse_entered<class_Control_signal_mouse_entered>`, :ref:`CollisionObject2D.mouse_entered<class_CollisionObject2D_signal_mouse_entered>`, :ref:`CollisionObject3D.mouse_entered<class_CollisionObject3D_signal_mouse_entered>` e :ref:`Window.mouse_entered<class_Window_signal_mouse_entered>` e delle rispettive controparti ``mouse_exited``.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_warp_mouse:
.. rst-class:: classref-method
|void| **warp_mouse**\ (\ position\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Viewport_method_warp_mouse>`
Sposta il puntatore del mouse nella posizione specificata in questa **Viewport** nel sistema di coordinate di questa **Viewport**.
\ **Nota:** :ref:`warp_mouse()<class_Viewport_method_warp_mouse>` è supportato solo su Windows, macOS e Linux. Non ha effetto su Android, iOS e Web.
.. |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