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_camera2d.rst
Rémi Verschelde b20bcbb88b Sync classref with 4.5 branch
2025-09-30 13:31:55 +02:00

852 lines
46 KiB
ReStructuredText
Raw Permalink Blame History

:github_url: hide
.. _class_Camera2D:
Camera2D
========
**Eredita:** :ref:`Node2D<class_Node2D>` **<** :ref:`CanvasItem<class_CanvasItem>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
Nodo di telecamera per le scene in 2D.
.. rst-class:: classref-introduction-group
Descrizione
----------------------
Nodo telecamera per le scene 2D. Forza lo schermo (livello attuale) a scorrere seguendo questo nodo. Ciò rende più facile (e veloce) programmare scene scorrevoli rispetto alla modifica manuale della posizione dei nodi basati su :ref:`CanvasItem<class_CanvasItem>`.
Le telecamere si registrano nel nodo :ref:`Viewport<class_Viewport>` più vicino (quando si sale nell'albero). Solo una telecamera può essere attiva per ogni viewport. Se non è disponibile alcuna viewport salendo nell'albero, la telecamera si registrerà nella viewport globale.
Questo nodo è pensato come aiuto per far funzionare le cose rapidamente, ma potrebbero essere desiderate più funzionalità per cambiare il modo in cui funziona la telecamera. Per creare il tuo nodo telecamera personalizzato, ereditalo da :ref:`Node2D<class_Node2D>` e modifica la trasformazione del canvas impostando :ref:`Viewport.canvas_transform<class_Viewport_property_canvas_transform>` in :ref:`Viewport<class_Viewport>` (puoi ottenere la :ref:`Viewport<class_Viewport>` attuale tramite :ref:`Node.get_viewport()<class_Node_method_get_viewport>`).
Nota che la :ref:`Node2D.global_position<class_Node2D_property_global_position>` del nodo **Camera2D** non rappresenta la posizione effettiva dello schermo, che potrebbe differire a causa di attenuazioni o limiti applicati. Puoi usare :ref:`get_screen_center_position()<class_Camera2D_method_get_screen_center_position>` per ottenere la posizione reale. Lo stesso vale per la :ref:`Node2D.global_rotation<class_Node2D_property_global_rotation>` del nodo, che potrebbe essere diversa a causa dell'applicazione dell'attenuazione della rotazione. È possibile usare :ref:`get_screen_rotation()<class_Camera2D_method_get_screen_rotation>` per ottenere la rotazione attuale dello schermo.
.. rst-class:: classref-introduction-group
Tutorial
----------------
- `Demo di gioco di piattaforme in 2D <https://godotengine.org/asset-library/asset/2727>`__
- `Demo isometrica 2D <https://godotengine.org/asset-library/asset/2718>`__
.. rst-class:: classref-reftable-group
Proprietà
------------------
.. table::
:widths: auto
+-----------------------------------------------------------------------+---------------------------------------------------------------------------------------+-------------------+
| :ref:`AnchorMode<enum_Camera2D_AnchorMode>` | :ref:`anchor_mode<class_Camera2D_property_anchor_mode>` | ``1`` |
+-----------------------------------------------------------------------+---------------------------------------------------------------------------------------+-------------------+
| :ref:`Node<class_Node>` | :ref:`custom_viewport<class_Camera2D_property_custom_viewport>` | |
+-----------------------------------------------------------------------+---------------------------------------------------------------------------------------+-------------------+
| :ref:`float<class_float>` | :ref:`drag_bottom_margin<class_Camera2D_property_drag_bottom_margin>` | ``0.2`` |
+-----------------------------------------------------------------------+---------------------------------------------------------------------------------------+-------------------+
| :ref:`bool<class_bool>` | :ref:`drag_horizontal_enabled<class_Camera2D_property_drag_horizontal_enabled>` | ``false`` |
+-----------------------------------------------------------------------+---------------------------------------------------------------------------------------+-------------------+
| :ref:`float<class_float>` | :ref:`drag_horizontal_offset<class_Camera2D_property_drag_horizontal_offset>` | ``0.0`` |
+-----------------------------------------------------------------------+---------------------------------------------------------------------------------------+-------------------+
| :ref:`float<class_float>` | :ref:`drag_left_margin<class_Camera2D_property_drag_left_margin>` | ``0.2`` |
+-----------------------------------------------------------------------+---------------------------------------------------------------------------------------+-------------------+
| :ref:`float<class_float>` | :ref:`drag_right_margin<class_Camera2D_property_drag_right_margin>` | ``0.2`` |
+-----------------------------------------------------------------------+---------------------------------------------------------------------------------------+-------------------+
| :ref:`float<class_float>` | :ref:`drag_top_margin<class_Camera2D_property_drag_top_margin>` | ``0.2`` |
+-----------------------------------------------------------------------+---------------------------------------------------------------------------------------+-------------------+
| :ref:`bool<class_bool>` | :ref:`drag_vertical_enabled<class_Camera2D_property_drag_vertical_enabled>` | ``false`` |
+-----------------------------------------------------------------------+---------------------------------------------------------------------------------------+-------------------+
| :ref:`float<class_float>` | :ref:`drag_vertical_offset<class_Camera2D_property_drag_vertical_offset>` | ``0.0`` |
+-----------------------------------------------------------------------+---------------------------------------------------------------------------------------+-------------------+
| :ref:`bool<class_bool>` | :ref:`editor_draw_drag_margin<class_Camera2D_property_editor_draw_drag_margin>` | ``false`` |
+-----------------------------------------------------------------------+---------------------------------------------------------------------------------------+-------------------+
| :ref:`bool<class_bool>` | :ref:`editor_draw_limits<class_Camera2D_property_editor_draw_limits>` | ``false`` |
+-----------------------------------------------------------------------+---------------------------------------------------------------------------------------+-------------------+
| :ref:`bool<class_bool>` | :ref:`editor_draw_screen<class_Camera2D_property_editor_draw_screen>` | ``true`` |
+-----------------------------------------------------------------------+---------------------------------------------------------------------------------------+-------------------+
| :ref:`bool<class_bool>` | :ref:`enabled<class_Camera2D_property_enabled>` | ``true`` |
+-----------------------------------------------------------------------+---------------------------------------------------------------------------------------+-------------------+
| :ref:`bool<class_bool>` | :ref:`ignore_rotation<class_Camera2D_property_ignore_rotation>` | ``true`` |
+-----------------------------------------------------------------------+---------------------------------------------------------------------------------------+-------------------+
| :ref:`int<class_int>` | :ref:`limit_bottom<class_Camera2D_property_limit_bottom>` | ``10000000`` |
+-----------------------------------------------------------------------+---------------------------------------------------------------------------------------+-------------------+
| :ref:`bool<class_bool>` | :ref:`limit_enabled<class_Camera2D_property_limit_enabled>` | ``true`` |
+-----------------------------------------------------------------------+---------------------------------------------------------------------------------------+-------------------+
| :ref:`int<class_int>` | :ref:`limit_left<class_Camera2D_property_limit_left>` | ``-10000000`` |
+-----------------------------------------------------------------------+---------------------------------------------------------------------------------------+-------------------+
| :ref:`int<class_int>` | :ref:`limit_right<class_Camera2D_property_limit_right>` | ``10000000`` |
+-----------------------------------------------------------------------+---------------------------------------------------------------------------------------+-------------------+
| :ref:`bool<class_bool>` | :ref:`limit_smoothed<class_Camera2D_property_limit_smoothed>` | ``false`` |
+-----------------------------------------------------------------------+---------------------------------------------------------------------------------------+-------------------+
| :ref:`int<class_int>` | :ref:`limit_top<class_Camera2D_property_limit_top>` | ``-10000000`` |
+-----------------------------------------------------------------------+---------------------------------------------------------------------------------------+-------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`offset<class_Camera2D_property_offset>` | ``Vector2(0, 0)`` |
+-----------------------------------------------------------------------+---------------------------------------------------------------------------------------+-------------------+
| :ref:`bool<class_bool>` | :ref:`position_smoothing_enabled<class_Camera2D_property_position_smoothing_enabled>` | ``false`` |
+-----------------------------------------------------------------------+---------------------------------------------------------------------------------------+-------------------+
| :ref:`float<class_float>` | :ref:`position_smoothing_speed<class_Camera2D_property_position_smoothing_speed>` | ``5.0`` |
+-----------------------------------------------------------------------+---------------------------------------------------------------------------------------+-------------------+
| :ref:`Camera2DProcessCallback<enum_Camera2D_Camera2DProcessCallback>` | :ref:`process_callback<class_Camera2D_property_process_callback>` | ``1`` |
+-----------------------------------------------------------------------+---------------------------------------------------------------------------------------+-------------------+
| :ref:`bool<class_bool>` | :ref:`rotation_smoothing_enabled<class_Camera2D_property_rotation_smoothing_enabled>` | ``false`` |
+-----------------------------------------------------------------------+---------------------------------------------------------------------------------------+-------------------+
| :ref:`float<class_float>` | :ref:`rotation_smoothing_speed<class_Camera2D_property_rotation_smoothing_speed>` | ``5.0`` |
+-----------------------------------------------------------------------+---------------------------------------------------------------------------------------+-------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`zoom<class_Camera2D_property_zoom>` | ``Vector2(1, 1)`` |
+-----------------------------------------------------------------------+---------------------------------------------------------------------------------------+-------------------+
.. rst-class:: classref-reftable-group
Metodi
------------
.. table::
:widths: auto
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`align<class_Camera2D_method_align>`\ (\ ) |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`force_update_scroll<class_Camera2D_method_force_update_scroll>`\ (\ ) |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`get_drag_margin<class_Camera2D_method_get_drag_margin>`\ (\ margin\: :ref:`Side<enum_@GlobalScope_Side>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_limit<class_Camera2D_method_get_limit>`\ (\ margin\: :ref:`Side<enum_@GlobalScope_Side>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`get_screen_center_position<class_Camera2D_method_get_screen_center_position>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`get_screen_rotation<class_Camera2D_method_get_screen_rotation>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`get_target_position<class_Camera2D_method_get_target_position>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_current<class_Camera2D_method_is_current>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`make_current<class_Camera2D_method_make_current>`\ (\ ) |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`reset_smoothing<class_Camera2D_method_reset_smoothing>`\ (\ ) |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_drag_margin<class_Camera2D_method_set_drag_margin>`\ (\ margin\: :ref:`Side<enum_@GlobalScope_Side>`, drag_margin\: :ref:`float<class_float>`\ ) |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_limit<class_Camera2D_method_set_limit>`\ (\ margin\: :ref:`Side<enum_@GlobalScope_Side>`, limit\: :ref:`int<class_int>`\ ) |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Enumerazioni
------------------------
.. _enum_Camera2D_AnchorMode:
.. rst-class:: classref-enumeration
enum **AnchorMode**: :ref:`🔗<enum_Camera2D_AnchorMode>`
.. _class_Camera2D_constant_ANCHOR_MODE_FIXED_TOP_LEFT:
.. rst-class:: classref-enumeration-constant
:ref:`AnchorMode<enum_Camera2D_AnchorMode>` **ANCHOR_MODE_FIXED_TOP_LEFT** = ``0``
La posizione della telecamera è fissa in modo che l'angolo in alto a sinistra sia sempre all'origine.
.. _class_Camera2D_constant_ANCHOR_MODE_DRAG_CENTER:
.. rst-class:: classref-enumeration-constant
:ref:`AnchorMode<enum_Camera2D_AnchorMode>` **ANCHOR_MODE_DRAG_CENTER** = ``1``
La posizione della telecamera tiene conto degli spostamenti verticale e orizzontale, e delle dimensioni dello schermo.
.. rst-class:: classref-item-separator
----
.. _enum_Camera2D_Camera2DProcessCallback:
.. rst-class:: classref-enumeration
enum **Camera2DProcessCallback**: :ref:`🔗<enum_Camera2D_Camera2DProcessCallback>`
.. _class_Camera2D_constant_CAMERA2D_PROCESS_PHYSICS:
.. rst-class:: classref-enumeration-constant
:ref:`Camera2DProcessCallback<enum_Camera2D_Camera2DProcessCallback>` **CAMERA2D_PROCESS_PHYSICS** = ``0``
La telecamera si aggiorna durante i frame di fisica (vedi :ref:`Node.NOTIFICATION_INTERNAL_PHYSICS_PROCESS<class_Node_constant_NOTIFICATION_INTERNAL_PHYSICS_PROCESS>`).
.. _class_Camera2D_constant_CAMERA2D_PROCESS_IDLE:
.. rst-class:: classref-enumeration-constant
:ref:`Camera2DProcessCallback<enum_Camera2D_Camera2DProcessCallback>` **CAMERA2D_PROCESS_IDLE** = ``1``
La telecamera si aggiorna durante i frame di processo (vedi :ref:`Node.NOTIFICATION_INTERNAL_PROCESS<class_Node_constant_NOTIFICATION_INTERNAL_PROCESS>`).
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descrizioni delle proprietà
------------------------------------------------------
.. _class_Camera2D_property_anchor_mode:
.. rst-class:: classref-property
:ref:`AnchorMode<enum_Camera2D_AnchorMode>` **anchor_mode** = ``1`` :ref:`🔗<class_Camera2D_property_anchor_mode>`
.. rst-class:: classref-property-setget
- |void| **set_anchor_mode**\ (\ value\: :ref:`AnchorMode<enum_Camera2D_AnchorMode>`\ )
- :ref:`AnchorMode<enum_Camera2D_AnchorMode>` **get_anchor_mode**\ (\ )
Il punto di ancoraggio della Camera2D.
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_property_custom_viewport:
.. rst-class:: classref-property
:ref:`Node<class_Node>` **custom_viewport** :ref:`🔗<class_Camera2D_property_custom_viewport>`
.. rst-class:: classref-property-setget
- |void| **set_custom_viewport**\ (\ value\: :ref:`Node<class_Node>`\ )
- :ref:`Node<class_Node>` **get_custom_viewport**\ (\ )
Il nodo :ref:`Viewport<class_Viewport>` personalizzato associato alla **Camera2D**. Se ``null`` o non è una :ref:`Viewport<class_Viewport>`, utilizza invece la viewport predefinita.
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_property_drag_bottom_margin:
.. rst-class:: classref-property
:ref:`float<class_float>` **drag_bottom_margin** = ``0.2`` :ref:`🔗<class_Camera2D_property_drag_bottom_margin>`
.. rst-class:: classref-property-setget
- |void| **set_drag_margin**\ (\ margin\: :ref:`Side<enum_@GlobalScope_Side>`, drag_margin\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_drag_margin**\ (\ margin\: :ref:`Side<enum_@GlobalScope_Side>`\ ) |const|
Margine inferiore necessario per trascinare la telecamera. Un valore di ``1`` fa muovere la telecamera solo quando raggiunge il bordo inferiore dello schermo.
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_property_drag_horizontal_enabled:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **drag_horizontal_enabled** = ``false`` :ref:`🔗<class_Camera2D_property_drag_horizontal_enabled>`
.. rst-class:: classref-property-setget
- |void| **set_drag_horizontal_enabled**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_drag_horizontal_enabled**\ (\ )
Se ``true``, la telecamera si muove solo quando raggiunge i margini di trascinamento orizzontali (sinistro e destro). Se ``false``, la telecamera si sposta orizzontalmente a prescindere dai margini di trascinamento.
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_property_drag_horizontal_offset:
.. rst-class:: classref-property
:ref:`float<class_float>` **drag_horizontal_offset** = ``0.0`` :ref:`🔗<class_Camera2D_property_drag_horizontal_offset>`
.. rst-class:: classref-property-setget
- |void| **set_drag_horizontal_offset**\ (\ value\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_drag_horizontal_offset**\ (\ )
Offset di trascinamento orizzontale relativo della telecamera tra i margini di trascinamento destro (``-1``) e sinistro (``1``).
\ **Nota:** Utilizzato per impostare l'offset di trascinamento orizzontale iniziale; determinare l'offset attuale; o forzare l'offset attuale. Non viene aggiornato automaticamente quando :ref:`drag_horizontal_enabled<class_Camera2D_property_drag_horizontal_enabled>` è ``true`` o i margini di trascinamento vengono modificati.
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_property_drag_left_margin:
.. rst-class:: classref-property
:ref:`float<class_float>` **drag_left_margin** = ``0.2`` :ref:`🔗<class_Camera2D_property_drag_left_margin>`
.. rst-class:: classref-property-setget
- |void| **set_drag_margin**\ (\ margin\: :ref:`Side<enum_@GlobalScope_Side>`, drag_margin\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_drag_margin**\ (\ margin\: :ref:`Side<enum_@GlobalScope_Side>`\ ) |const|
Margine sinistro necessario per trascinare la telecamera. Un valore di ``1`` fa muovere la telecamera solo quando raggiunge il bordo sinistro dello schermo.
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_property_drag_right_margin:
.. rst-class:: classref-property
:ref:`float<class_float>` **drag_right_margin** = ``0.2`` :ref:`🔗<class_Camera2D_property_drag_right_margin>`
.. rst-class:: classref-property-setget
- |void| **set_drag_margin**\ (\ margin\: :ref:`Side<enum_@GlobalScope_Side>`, drag_margin\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_drag_margin**\ (\ margin\: :ref:`Side<enum_@GlobalScope_Side>`\ ) |const|
Margine destro necessario per trascinare la telecamera. Un valore di ``1`` fa muovere la telecamera solo quando raggiunge il bordo destro dello schermo.
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_property_drag_top_margin:
.. rst-class:: classref-property
:ref:`float<class_float>` **drag_top_margin** = ``0.2`` :ref:`🔗<class_Camera2D_property_drag_top_margin>`
.. rst-class:: classref-property-setget
- |void| **set_drag_margin**\ (\ margin\: :ref:`Side<enum_@GlobalScope_Side>`, drag_margin\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_drag_margin**\ (\ margin\: :ref:`Side<enum_@GlobalScope_Side>`\ ) |const|
Margine superiore necessario per trascinare la telecamera. Un valore di ``1`` fa muovere la telecamera solo quando raggiunge il bordo superiore dello schermo.
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_property_drag_vertical_enabled:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **drag_vertical_enabled** = ``false`` :ref:`🔗<class_Camera2D_property_drag_vertical_enabled>`
.. rst-class:: classref-property-setget
- |void| **set_drag_vertical_enabled**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_drag_vertical_enabled**\ (\ )
Se ``true``, la telecamera si muove solo quando raggiunge i margini di trascinamento verticali (sopra e sotto). Se ``false``, la telecamera si sposta verticalmente a prescindere dai margini di trascinamento.
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_property_drag_vertical_offset:
.. rst-class:: classref-property
:ref:`float<class_float>` **drag_vertical_offset** = ``0.0`` :ref:`🔗<class_Camera2D_property_drag_vertical_offset>`
.. rst-class:: classref-property-setget
- |void| **set_drag_vertical_offset**\ (\ value\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_drag_vertical_offset**\ (\ )
Offset di trascinamento verticale relativo della telecamera tra i margini di trascinamento inferiore (``-1``) e superiore (``1``).
\ **Nota:** Utilizzato per impostare l'offset di trascinamento verticale iniziale; determinare l'offset attuale; o forzare l'offset attuale. Non viene aggiornato automaticamente quando :ref:`drag_vertical_enabled<class_Camera2D_property_drag_vertical_enabled>` è ``true`` o i margini di trascinamento vengono modificati.
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_property_editor_draw_drag_margin:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **editor_draw_drag_margin** = ``false`` :ref:`🔗<class_Camera2D_property_editor_draw_drag_margin>`
.. rst-class:: classref-property-setget
- |void| **set_margin_drawing_enabled**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_margin_drawing_enabled**\ (\ )
Se ``true``, disegna il rettangolo del margine di trascinamento della telecamera nell'editor.
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_property_editor_draw_limits:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **editor_draw_limits** = ``false`` :ref:`🔗<class_Camera2D_property_editor_draw_limits>`
.. rst-class:: classref-property-setget
- |void| **set_limit_drawing_enabled**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_limit_drawing_enabled**\ (\ )
Se ``true``, disegna il rettangolo dei limiti della telecamera nell'editor.
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_property_editor_draw_screen:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **editor_draw_screen** = ``true`` :ref:`🔗<class_Camera2D_property_editor_draw_screen>`
.. rst-class:: classref-property-setget
- |void| **set_screen_drawing_enabled**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_screen_drawing_enabled**\ (\ )
Se ``true``, disegna il rettangolo dello schermo della telecamera nell'editor.
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_property_enabled:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **enabled** = ``true`` :ref:`🔗<class_Camera2D_property_enabled>`
.. rst-class:: classref-property-setget
- |void| **set_enabled**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_enabled**\ (\ )
Controlla se la fotocamera può essere attiva o meno. Se ``true``, la **Camera2D** diventerà la telecamera principale quando entra nell'albero di scene e non vi è alcuna telecamera attiva attuale (vedi :ref:`Viewport.get_camera_2d()<class_Viewport_method_get_camera_2d>`).
Quando la telecamera è attualmente attiva e :ref:`enabled<class_Camera2D_property_enabled>` è impostato su ``false``, la successiva **Camera2D** abilitata nell'albero di scene diventerà attiva.
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_property_ignore_rotation:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **ignore_rotation** = ``true`` :ref:`🔗<class_Camera2D_property_ignore_rotation>`
.. rst-class:: classref-property-setget
- |void| **set_ignore_rotation**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_ignoring_rotation**\ (\ )
Se ``true``, la vista renderizzata della telecamera non è influenzata dal suo :ref:`Node2D.rotation<class_Node2D_property_rotation>` e :ref:`Node2D.global_rotation<class_Node2D_property_global_rotation>`.
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_property_limit_bottom:
.. rst-class:: classref-property
:ref:`int<class_int>` **limit_bottom** = ``10000000`` :ref:`🔗<class_Camera2D_property_limit_bottom>`
.. rst-class:: classref-property-setget
- |void| **set_limit**\ (\ margin\: :ref:`Side<enum_@GlobalScope_Side>`, limit\: :ref:`int<class_int>`\ )
- :ref:`int<class_int>` **get_limit**\ (\ margin\: :ref:`Side<enum_@GlobalScope_Side>`\ ) |const|
Limite di scorrimento inferiore in pixel. La telecamera smette di muoversi quando raggiunge questo valore, ma :ref:`offset<class_Camera2D_property_offset>` può spingere la vista oltre il limite.
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_property_limit_enabled:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **limit_enabled** = ``true`` :ref:`🔗<class_Camera2D_property_limit_enabled>`
.. rst-class:: classref-property-setget
- |void| **set_limit_enabled**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_limit_enabled**\ (\ )
Se ``true``, i limiti saranno abilitati. Disabilitandoli, la telecamera potrà focalizzarsi ovunque, quando le quattro proprietà ``limit_*`` non funzioneranno.
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_property_limit_left:
.. rst-class:: classref-property
:ref:`int<class_int>` **limit_left** = ``-10000000`` :ref:`🔗<class_Camera2D_property_limit_left>`
.. rst-class:: classref-property-setget
- |void| **set_limit**\ (\ margin\: :ref:`Side<enum_@GlobalScope_Side>`, limit\: :ref:`int<class_int>`\ )
- :ref:`int<class_int>` **get_limit**\ (\ margin\: :ref:`Side<enum_@GlobalScope_Side>`\ ) |const|
Limite di scorrimento sinistro in pixel. La telecamera smette di muoversi quando raggiunge questo valore, ma :ref:`offset<class_Camera2D_property_offset>` può spingere la vista oltre il limite.
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_property_limit_right:
.. rst-class:: classref-property
:ref:`int<class_int>` **limit_right** = ``10000000`` :ref:`🔗<class_Camera2D_property_limit_right>`
.. rst-class:: classref-property-setget
- |void| **set_limit**\ (\ margin\: :ref:`Side<enum_@GlobalScope_Side>`, limit\: :ref:`int<class_int>`\ )
- :ref:`int<class_int>` **get_limit**\ (\ margin\: :ref:`Side<enum_@GlobalScope_Side>`\ ) |const|
Limite di scorrimento destro in pixel. La telecamera smette di muoversi quando raggiunge questo valore, ma :ref:`offset<class_Camera2D_property_offset>` può spingere la vista oltre il limite.
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_property_limit_smoothed:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **limit_smoothed** = ``false`` :ref:`🔗<class_Camera2D_property_limit_smoothed>`
.. rst-class:: classref-property-setget
- |void| **set_limit_smoothing_enabled**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_limit_smoothing_enabled**\ (\ )
Se ``true``, la fotocamera si ferma dolcemente quando raggiunge i suoi limiti.
Questa proprietà non ha effetto se :ref:`position_smoothing_enabled<class_Camera2D_property_position_smoothing_enabled>` è ``false``.
\ **Nota:** Per aggiornare immediatamente la posizione della telecamera in modo che rientri nei limiti di attenuazione, anche con questa impostazione abilitata, invoca :ref:`reset_smoothing()<class_Camera2D_method_reset_smoothing>`.
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_property_limit_top:
.. rst-class:: classref-property
:ref:`int<class_int>` **limit_top** = ``-10000000`` :ref:`🔗<class_Camera2D_property_limit_top>`
.. rst-class:: classref-property-setget
- |void| **set_limit**\ (\ margin\: :ref:`Side<enum_@GlobalScope_Side>`, limit\: :ref:`int<class_int>`\ )
- :ref:`int<class_int>` **get_limit**\ (\ margin\: :ref:`Side<enum_@GlobalScope_Side>`\ ) |const|
Limite di scorrimento superiore in pixel. La telecamera smette di muoversi quando raggiunge questo valore, ma :ref:`offset<class_Camera2D_property_offset>` può spingere la vista oltre il limite.
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_property_offset:
.. rst-class:: classref-property
:ref:`Vector2<class_Vector2>` **offset** = ``Vector2(0, 0)`` :ref:`🔗<class_Camera2D_property_offset>`
.. rst-class:: classref-property-setget
- |void| **set_offset**\ (\ value\: :ref:`Vector2<class_Vector2>`\ )
- :ref:`Vector2<class_Vector2>` **get_offset**\ (\ )
Spostamento relativo della fotocamera. Utile per guardarsi intorno o animazioni di scuotimento dalla telecamera. La telecamera spostata può superare i limiti definiti in :ref:`limit_top<class_Camera2D_property_limit_top>`, :ref:`limit_bottom<class_Camera2D_property_limit_bottom>`, :ref:`limit_left<class_Camera2D_property_limit_left>`, e :ref:`limit_right<class_Camera2D_property_limit_right>`.
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_property_position_smoothing_enabled:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **position_smoothing_enabled** = ``false`` :ref:`🔗<class_Camera2D_property_position_smoothing_enabled>`
.. rst-class:: classref-property-setget
- |void| **set_position_smoothing_enabled**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_position_smoothing_enabled**\ (\ )
Se ``true``, la vista della telecamera si muove fluidamente verso la sua posizione di destinazione alla velocità di :ref:`position_smoothing_speed<class_Camera2D_property_position_smoothing_speed>`.
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_property_position_smoothing_speed:
.. rst-class:: classref-property
:ref:`float<class_float>` **position_smoothing_speed** = ``5.0`` :ref:`🔗<class_Camera2D_property_position_smoothing_speed>`
.. rst-class:: classref-property-setget
- |void| **set_position_smoothing_speed**\ (\ value\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_position_smoothing_speed**\ (\ )
Velocità in pixel al secondo dell'effetto di attenuazione della fotocamera quando :ref:`position_smoothing_enabled<class_Camera2D_property_position_smoothing_enabled>` è ``true``.
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_property_process_callback:
.. rst-class:: classref-property
:ref:`Camera2DProcessCallback<enum_Camera2D_Camera2DProcessCallback>` **process_callback** = ``1`` :ref:`🔗<class_Camera2D_property_process_callback>`
.. rst-class:: classref-property-setget
- |void| **set_process_callback**\ (\ value\: :ref:`Camera2DProcessCallback<enum_Camera2D_Camera2DProcessCallback>`\ )
- :ref:`Camera2DProcessCallback<enum_Camera2D_Camera2DProcessCallback>` **get_process_callback**\ (\ )
Il callback di processo della telecamera.
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_property_rotation_smoothing_enabled:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **rotation_smoothing_enabled** = ``false`` :ref:`🔗<class_Camera2D_property_rotation_smoothing_enabled>`
.. rst-class:: classref-property-setget
- |void| **set_rotation_smoothing_enabled**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_rotation_smoothing_enabled**\ (\ )
Se ``true``, la visuale della telecamera ruota dolcemente, tramite attenuazione asintotica, per allinearsi con la rotazione di destinazione a :ref:`rotation_smoothing_speed<class_Camera2D_property_rotation_smoothing_speed>`.
\ **Nota:** Questa proprietà non ha effetto se :ref:`ignore_rotation<class_Camera2D_property_ignore_rotation>` è ``true``.
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_property_rotation_smoothing_speed:
.. rst-class:: classref-property
:ref:`float<class_float>` **rotation_smoothing_speed** = ``5.0`` :ref:`🔗<class_Camera2D_property_rotation_smoothing_speed>`
.. rst-class:: classref-property-setget
- |void| **set_rotation_smoothing_speed**\ (\ value\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_rotation_smoothing_speed**\ (\ )
Velocità angolare asintotica dell'effetto di attenuazione della rotazione della telecamera quando :ref:`rotation_smoothing_enabled<class_Camera2D_property_rotation_smoothing_enabled>` è ``true``.
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_property_zoom:
.. rst-class:: classref-property
:ref:`Vector2<class_Vector2>` **zoom** = ``Vector2(1, 1)`` :ref:`🔗<class_Camera2D_property_zoom>`
.. rst-class:: classref-property-setget
- |void| **set_zoom**\ (\ value\: :ref:`Vector2<class_Vector2>`\ )
- :ref:`Vector2<class_Vector2>` **get_zoom**\ (\ )
Lo zoom della telecamera. Valori più alti risultano in un ingrandimento maggiore. Ad esempio, uno zoom di ``Vector2(2.0, 2.0)`` raddoppia l'ingrandimento su ciascun asse (la vista copre un'area quattro volte più piccola). Al contrario, uno zoom di ``Vector2(0.5, 0.5)`` rimpicciolirà di due volte su ciascun asse (la vista copre un'area quattro volte più grande). In genere, le componenti X e Y si dovrebbero sempre impostare sullo stesso valore, a meno che non si desideri stirare la vista della telecamera.
\ **Nota:** :ref:`FontFile.oversampling<class_FontFile_property_oversampling>` *non* tiene conto dello zoom della **Camera2D**. Ciò significa che lo zoom in avanti/indietro farà in modo che i font bitmap e i font dinamici rasterizzati (non MSDF) appaiano sfocati o pixelati, a meno che il font non faccia parte di un :ref:`CanvasLayer<class_CanvasLayer>` che gli fa ignorare lo zoom della telecamera. Per garantire che il testo rimanga nitido a prescindere dallo zoom, è possibile abilitare il rendering dei font MSDF abilitando :ref:`ProjectSettings.gui/theme/default_font_multichannel_signed_distance_field<class_ProjectSettings_property_gui/theme/default_font_multichannel_signed_distance_field>` (si applica solo al font predefinito del progetto) o abilitando **Multichannel Signed Distance Field** nelle opzioni di importazione di un DynamicFont per i font personalizzati. Sui font di sistema, è possibile abilitare :ref:`SystemFont.multichannel_signed_distance_field<class_SystemFont_property_multichannel_signed_distance_field>` nell'Ispettore.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descrizioni dei metodi
--------------------------------------------
.. _class_Camera2D_method_align:
.. rst-class:: classref-method
|void| **align**\ (\ ) :ref:`🔗<class_Camera2D_method_align>`
Allinea la telecamera al nodo tracciato.
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_method_force_update_scroll:
.. rst-class:: classref-method
|void| **force_update_scroll**\ (\ ) :ref:`🔗<class_Camera2D_method_force_update_scroll>`
Forza la telecamera ad aggiornare lo scorrimento immediatamente.
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_method_get_drag_margin:
.. rst-class:: classref-method
:ref:`float<class_float>` **get_drag_margin**\ (\ margin\: :ref:`Side<enum_@GlobalScope_Side>`\ ) |const| :ref:`🔗<class_Camera2D_method_get_drag_margin>`
Restituisce il margine del lato specificato (vedi :ref:`Side<enum_@GlobalScope_Side>`). Vedi anche :ref:`drag_bottom_margin<class_Camera2D_property_drag_bottom_margin>`, :ref:`drag_top_margin<class_Camera2D_property_drag_top_margin>`, :ref:`drag_left_margin<class_Camera2D_property_drag_left_margin>`, e :ref:`drag_right_margin<class_Camera2D_property_drag_right_margin>`.
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_method_get_limit:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_limit**\ (\ margin\: :ref:`Side<enum_@GlobalScope_Side>`\ ) |const| :ref:`🔗<class_Camera2D_method_get_limit>`
Restituisce il limite della telecamera per il lato specificato (vedi :ref:`Side<enum_@GlobalScope_Side>`). Vedi anche :ref:`limit_bottom<class_Camera2D_property_limit_bottom>`, :ref:`limit_top<class_Camera2D_property_limit_top>`, :ref:`limit_left<class_Camera2D_property_limit_left>`, e :ref:`limit_right<class_Camera2D_property_limit_right>`.
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_method_get_screen_center_position:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **get_screen_center_position**\ (\ ) |const| :ref:`🔗<class_Camera2D_method_get_screen_center_position>`
Restituisce il centro dello schermo dal punto di vista di questa telecamera, in coordinate globali.
\ **Nota:** L'esatta posizione di destinazione della fotocamera potrebbe essere diversa. Vedi :ref:`get_target_position()<class_Camera2D_method_get_target_position>`.
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_method_get_screen_rotation:
.. rst-class:: classref-method
:ref:`float<class_float>` **get_screen_rotation**\ (\ ) |const| :ref:`🔗<class_Camera2D_method_get_screen_rotation>`
Restituisce la rotazione attuale dello schermo dal punto di vista di questa telecamera.
\ **Nota:** La rotazione dello schermo può essere diversa da :ref:`Node2D.global_rotation<class_Node2D_property_global_rotation>` se la telecamera ruota in modo fluido a causa di :ref:`rotation_smoothing_enabled<class_Camera2D_property_rotation_smoothing_enabled>`.
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_method_get_target_position:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **get_target_position**\ (\ ) |const| :ref:`🔗<class_Camera2D_method_get_target_position>`
Restituisce la posizione di destinazione di questa telecamera, in coordinate globali.
\ **Nota:** Il valore restituito non è lo stesso di :ref:`Node2D.global_position<class_Node2D_property_global_position>`, poiché è influenzato dalle proprietà di trascinamento. Inoltre, non è lo stesso della posizione attuale se :ref:`position_smoothing_enabled<class_Camera2D_property_position_smoothing_enabled>` è ``true`` (vedi :ref:`get_screen_center_position()<class_Camera2D_method_get_screen_center_position>`).
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_method_is_current:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_current**\ (\ ) |const| :ref:`🔗<class_Camera2D_method_is_current>`
Restituisce ``true`` se questa **Camera2D** è la telecamera attiva (vedi :ref:`Viewport.get_camera_2d()<class_Viewport_method_get_camera_2d>`).
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_method_make_current:
.. rst-class:: classref-method
|void| **make_current**\ (\ ) :ref:`🔗<class_Camera2D_method_make_current>`
Forza questa **Camera2D** a diventare quella attualmente attiva. :ref:`enabled<class_Camera2D_property_enabled>` deve essere ``true``.
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_method_reset_smoothing:
.. rst-class:: classref-method
|void| **reset_smoothing**\ (\ ) :ref:`🔗<class_Camera2D_method_reset_smoothing>`
Imposta la posizione della telecamera immediatamente sulla sua destinazione di attenuamento corrente.
Questo metodo non ha alcun effetto se :ref:`position_smoothing_enabled<class_Camera2D_property_position_smoothing_enabled>` è ``false``.
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_method_set_drag_margin:
.. rst-class:: classref-method
|void| **set_drag_margin**\ (\ margin\: :ref:`Side<enum_@GlobalScope_Side>`, drag_margin\: :ref:`float<class_float>`\ ) :ref:`🔗<class_Camera2D_method_set_drag_margin>`
Imposta il margine del lato specificato (vedi :ref:`Side<enum_@GlobalScope_Side>`). Vedi anche :ref:`drag_bottom_margin<class_Camera2D_property_drag_bottom_margin>`, :ref:`drag_top_margin<class_Camera2D_property_drag_top_margin>`, :ref:`drag_left_margin<class_Camera2D_property_drag_left_margin>`, e :ref:`drag_right_margin<class_Camera2D_property_drag_right_margin>`.
.. rst-class:: classref-item-separator
----
.. _class_Camera2D_method_set_limit:
.. rst-class:: classref-method
|void| **set_limit**\ (\ margin\: :ref:`Side<enum_@GlobalScope_Side>`, limit\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Camera2D_method_set_limit>`
Imposta il limite della telecamera per il lato specificato (vedi :ref:`Side<enum_@GlobalScope_Side>`). Vedi anche :ref:`limit_bottom<class_Camera2D_property_limit_bottom>`, :ref:`limit_top<class_Camera2D_property_limit_top>`, :ref:`limit_left<class_Camera2D_property_limit_left>`, e :ref:`limit_right<class_Camera2D_property_limit_right>`.
.. |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