mirror of
https://github.com/godotengine/godot-docs-l10n.git
synced 2025-12-31 09:49:22 +03:00
465 lines
24 KiB
ReStructuredText
465 lines
24 KiB
ReStructuredText
:github_url: hide
|
|
|
|
.. _class_Node2D:
|
|
|
|
Node2D
|
|
======
|
|
|
|
**Eredita:** :ref:`CanvasItem<class_CanvasItem>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
|
|
|
|
**Ereditato da:** :ref:`AnimatedSprite2D<class_AnimatedSprite2D>`, :ref:`AudioListener2D<class_AudioListener2D>`, :ref:`AudioStreamPlayer2D<class_AudioStreamPlayer2D>`, :ref:`BackBufferCopy<class_BackBufferCopy>`, :ref:`Bone2D<class_Bone2D>`, :ref:`Camera2D<class_Camera2D>`, :ref:`CanvasGroup<class_CanvasGroup>`, :ref:`CanvasModulate<class_CanvasModulate>`, :ref:`CollisionObject2D<class_CollisionObject2D>`, :ref:`CollisionPolygon2D<class_CollisionPolygon2D>`, :ref:`CollisionShape2D<class_CollisionShape2D>`, :ref:`CPUParticles2D<class_CPUParticles2D>`, :ref:`GPUParticles2D<class_GPUParticles2D>`, :ref:`Joint2D<class_Joint2D>`, :ref:`Light2D<class_Light2D>`, :ref:`LightOccluder2D<class_LightOccluder2D>`, :ref:`Line2D<class_Line2D>`, :ref:`Marker2D<class_Marker2D>`, :ref:`MeshInstance2D<class_MeshInstance2D>`, :ref:`MultiMeshInstance2D<class_MultiMeshInstance2D>`, :ref:`NavigationLink2D<class_NavigationLink2D>`, :ref:`NavigationObstacle2D<class_NavigationObstacle2D>`, :ref:`NavigationRegion2D<class_NavigationRegion2D>`, :ref:`Parallax2D<class_Parallax2D>`, :ref:`ParallaxLayer<class_ParallaxLayer>`, :ref:`Path2D<class_Path2D>`, :ref:`PathFollow2D<class_PathFollow2D>`, :ref:`Polygon2D<class_Polygon2D>`, :ref:`RayCast2D<class_RayCast2D>`, :ref:`RemoteTransform2D<class_RemoteTransform2D>`, :ref:`ShapeCast2D<class_ShapeCast2D>`, :ref:`Skeleton2D<class_Skeleton2D>`, :ref:`Sprite2D<class_Sprite2D>`, :ref:`TileMap<class_TileMap>`, :ref:`TileMapLayer<class_TileMapLayer>`, :ref:`TouchScreenButton<class_TouchScreenButton>`, :ref:`VisibleOnScreenNotifier2D<class_VisibleOnScreenNotifier2D>`
|
|
|
|
Un oggetto di gioco 2D, ereditato da tutti i nodi riguardanti il 2D. Ha una posizione, una rotazione, una scala e un'inclinazione.
|
|
|
|
.. rst-class:: classref-introduction-group
|
|
|
|
Descrizione
|
|
----------------------
|
|
|
|
Un oggetto di gioco 2D, con una trasformazione (posizione, rotazione e scala). Tutti i nodi 2D, inclusi gli oggetti di fisica e gli sprite, ereditano da Node2D. Utilizza Node2D come nodo genitore per spostare, scalare e ruotare i figli in un progetto 2D. Offre inoltre il controllo dell'ordine di rendering del nodo.
|
|
|
|
\ **Nota:** Poiché sia **Node2D** sia :ref:`Control<class_Control>` ereditano da :ref:`CanvasItem<class_CanvasItem>`, essi condividono diversi concetti della classe come le proprietà :ref:`CanvasItem.z_index<class_CanvasItem_property_z_index>` e :ref:`CanvasItem.visible<class_CanvasItem_property_visible>`.
|
|
|
|
.. rst-class:: classref-introduction-group
|
|
|
|
Tutorial
|
|
----------------
|
|
|
|
- :doc:`Disegno personalizzato in 2D <../tutorials/2d/custom_drawing_in_2d>`
|
|
|
|
- `Tutte le demo 2D <https://github.com/godotengine/godot-demo-projects/tree/master/2d>`__
|
|
|
|
.. rst-class:: classref-reftable-group
|
|
|
|
Proprietà
|
|
------------------
|
|
|
|
.. table::
|
|
:widths: auto
|
|
|
|
+---------------------------------------+-------------------------------------------------------------------------------+-------------------+
|
|
| :ref:`Vector2<class_Vector2>` | :ref:`global_position<class_Node2D_property_global_position>` | |
|
|
+---------------------------------------+-------------------------------------------------------------------------------+-------------------+
|
|
| :ref:`float<class_float>` | :ref:`global_rotation<class_Node2D_property_global_rotation>` | |
|
|
+---------------------------------------+-------------------------------------------------------------------------------+-------------------+
|
|
| :ref:`float<class_float>` | :ref:`global_rotation_degrees<class_Node2D_property_global_rotation_degrees>` | |
|
|
+---------------------------------------+-------------------------------------------------------------------------------+-------------------+
|
|
| :ref:`Vector2<class_Vector2>` | :ref:`global_scale<class_Node2D_property_global_scale>` | |
|
|
+---------------------------------------+-------------------------------------------------------------------------------+-------------------+
|
|
| :ref:`float<class_float>` | :ref:`global_skew<class_Node2D_property_global_skew>` | |
|
|
+---------------------------------------+-------------------------------------------------------------------------------+-------------------+
|
|
| :ref:`Transform2D<class_Transform2D>` | :ref:`global_transform<class_Node2D_property_global_transform>` | |
|
|
+---------------------------------------+-------------------------------------------------------------------------------+-------------------+
|
|
| :ref:`Vector2<class_Vector2>` | :ref:`position<class_Node2D_property_position>` | ``Vector2(0, 0)`` |
|
|
+---------------------------------------+-------------------------------------------------------------------------------+-------------------+
|
|
| :ref:`float<class_float>` | :ref:`rotation<class_Node2D_property_rotation>` | ``0.0`` |
|
|
+---------------------------------------+-------------------------------------------------------------------------------+-------------------+
|
|
| :ref:`float<class_float>` | :ref:`rotation_degrees<class_Node2D_property_rotation_degrees>` | |
|
|
+---------------------------------------+-------------------------------------------------------------------------------+-------------------+
|
|
| :ref:`Vector2<class_Vector2>` | :ref:`scale<class_Node2D_property_scale>` | ``Vector2(1, 1)`` |
|
|
+---------------------------------------+-------------------------------------------------------------------------------+-------------------+
|
|
| :ref:`float<class_float>` | :ref:`skew<class_Node2D_property_skew>` | ``0.0`` |
|
|
+---------------------------------------+-------------------------------------------------------------------------------+-------------------+
|
|
| :ref:`Transform2D<class_Transform2D>` | :ref:`transform<class_Node2D_property_transform>` | |
|
|
+---------------------------------------+-------------------------------------------------------------------------------+-------------------+
|
|
|
|
.. rst-class:: classref-reftable-group
|
|
|
|
Metodi
|
|
------------
|
|
|
|
.. table::
|
|
:widths: auto
|
|
|
|
+---------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`apply_scale<class_Node2D_method_apply_scale>`\ (\ ratio\: :ref:`Vector2<class_Vector2>`\ ) |
|
|
+---------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`get_angle_to<class_Node2D_method_get_angle_to>`\ (\ point\: :ref:`Vector2<class_Vector2>`\ ) |const| |
|
|
+---------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Transform2D<class_Transform2D>` | :ref:`get_relative_transform_to_parent<class_Node2D_method_get_relative_transform_to_parent>`\ (\ parent\: :ref:`Node<class_Node>`\ ) |const| |
|
|
+---------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`global_translate<class_Node2D_method_global_translate>`\ (\ offset\: :ref:`Vector2<class_Vector2>`\ ) |
|
|
+---------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`look_at<class_Node2D_method_look_at>`\ (\ point\: :ref:`Vector2<class_Vector2>`\ ) |
|
|
+---------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`move_local_x<class_Node2D_method_move_local_x>`\ (\ delta\: :ref:`float<class_float>`, scaled\: :ref:`bool<class_bool>` = false\ ) |
|
|
+---------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`move_local_y<class_Node2D_method_move_local_y>`\ (\ delta\: :ref:`float<class_float>`, scaled\: :ref:`bool<class_bool>` = false\ ) |
|
|
+---------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`rotate<class_Node2D_method_rotate>`\ (\ radians\: :ref:`float<class_float>`\ ) |
|
|
+---------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Vector2<class_Vector2>` | :ref:`to_global<class_Node2D_method_to_global>`\ (\ local_point\: :ref:`Vector2<class_Vector2>`\ ) |const| |
|
|
+---------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Vector2<class_Vector2>` | :ref:`to_local<class_Node2D_method_to_local>`\ (\ global_point\: :ref:`Vector2<class_Vector2>`\ ) |const| |
|
|
+---------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`translate<class_Node2D_method_translate>`\ (\ offset\: :ref:`Vector2<class_Vector2>`\ ) |
|
|
+---------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------+
|
|
|
|
.. rst-class:: classref-section-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-descriptions-group
|
|
|
|
Descrizioni delle proprietà
|
|
------------------------------------------------------
|
|
|
|
.. _class_Node2D_property_global_position:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`Vector2<class_Vector2>` **global_position** :ref:`🔗<class_Node2D_property_global_position>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_global_position**\ (\ value\: :ref:`Vector2<class_Vector2>`\ )
|
|
- :ref:`Vector2<class_Vector2>` **get_global_position**\ (\ )
|
|
|
|
La posizione globale. Vedi anche :ref:`position<class_Node2D_property_position>`.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Node2D_property_global_rotation:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`float<class_float>` **global_rotation** :ref:`🔗<class_Node2D_property_global_rotation>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_global_rotation**\ (\ value\: :ref:`float<class_float>`\ )
|
|
- :ref:`float<class_float>` **get_global_rotation**\ (\ )
|
|
|
|
Rotazione globale in radianti. Vedi anche :ref:`rotation<class_Node2D_property_rotation>`.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Node2D_property_global_rotation_degrees:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`float<class_float>` **global_rotation_degrees** :ref:`🔗<class_Node2D_property_global_rotation_degrees>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_global_rotation_degrees**\ (\ value\: :ref:`float<class_float>`\ )
|
|
- :ref:`float<class_float>` **get_global_rotation_degrees**\ (\ )
|
|
|
|
Proprietà di supporto per accedere a :ref:`global_rotation<class_Node2D_property_global_rotation>` in gradi anziché in radianti. Vedi anche :ref:`rotation_degrees<class_Node2D_property_rotation_degrees>`.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Node2D_property_global_scale:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`Vector2<class_Vector2>` **global_scale** :ref:`🔗<class_Node2D_property_global_scale>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_global_scale**\ (\ value\: :ref:`Vector2<class_Vector2>`\ )
|
|
- :ref:`Vector2<class_Vector2>` **get_global_scale**\ (\ )
|
|
|
|
Scala globale. Vedi anche :ref:`scale<class_Node2D_property_scale>`.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Node2D_property_global_skew:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`float<class_float>` **global_skew** :ref:`🔗<class_Node2D_property_global_skew>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_global_skew**\ (\ value\: :ref:`float<class_float>`\ )
|
|
- :ref:`float<class_float>` **get_global_skew**\ (\ )
|
|
|
|
Inclinazione globale in radianti. Vedi anche :ref:`skew<class_Node2D_property_skew>`.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Node2D_property_global_transform:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`Transform2D<class_Transform2D>` **global_transform** :ref:`🔗<class_Node2D_property_global_transform>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_global_transform**\ (\ value\: :ref:`Transform2D<class_Transform2D>`\ )
|
|
- :ref:`Transform2D<class_Transform2D>` **get_global_transform**\ (\ )
|
|
|
|
:ref:`Transform2D<class_Transform2D>` globale. Vedi anche :ref:`transform<class_Node2D_property_transform>`.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Node2D_property_position:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`Vector2<class_Vector2>` **position** = ``Vector2(0, 0)`` :ref:`🔗<class_Node2D_property_position>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_position**\ (\ value\: :ref:`Vector2<class_Vector2>`\ )
|
|
- :ref:`Vector2<class_Vector2>` **get_position**\ (\ )
|
|
|
|
Posizione, relativa al nodo genitore. Vedi anche :ref:`global_position<class_Node2D_property_global_position>`.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Node2D_property_rotation:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`float<class_float>` **rotation** = ``0.0`` :ref:`🔗<class_Node2D_property_rotation>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_rotation**\ (\ value\: :ref:`float<class_float>`\ )
|
|
- :ref:`float<class_float>` **get_rotation**\ (\ )
|
|
|
|
Rotazione in radianti, relativa al genitore del nodo. Vedi anche :ref:`global_rotation<class_Node2D_property_global_rotation>`.
|
|
|
|
\ **Nota:** Questa proprietà è modificata nell'ispettore in gradi. Se vuoi usare i gradi in uno script, usa :ref:`rotation_degrees<class_Node2D_property_rotation_degrees>`.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Node2D_property_rotation_degrees:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`float<class_float>` **rotation_degrees** :ref:`🔗<class_Node2D_property_rotation_degrees>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_rotation_degrees**\ (\ value\: :ref:`float<class_float>`\ )
|
|
- :ref:`float<class_float>` **get_rotation_degrees**\ (\ )
|
|
|
|
Proprietà ausiliare per accedere a :ref:`rotation<class_Node2D_property_rotation>` in gradi anziché in radianti. Vedi anche :ref:`global_rotation_degrees<class_Node2D_property_global_rotation_degrees>`.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Node2D_property_scale:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`Vector2<class_Vector2>` **scale** = ``Vector2(1, 1)`` :ref:`🔗<class_Node2D_property_scale>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_scale**\ (\ value\: :ref:`Vector2<class_Vector2>`\ )
|
|
- :ref:`Vector2<class_Vector2>` **get_scale**\ (\ )
|
|
|
|
La scala del nodo, relativa al genitore del nodo. Valore non scalato: ``(1, 1)``. Vedi anche :ref:`global_scale<class_Node2D_property_global_scale>`.
|
|
|
|
\ **Nota:** Le scale X negative in 2D non sono scomponibili dalla matrice di trasformazione. A causa del modo in cui la scala è rappresentata con le matrici di trasformazione in Godot, le scale negative sull'asse X saranno modificate in scale negative sull'asse Y e una rotazione di 180 gradi quando scomposte.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Node2D_property_skew:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`float<class_float>` **skew** = ``0.0`` :ref:`🔗<class_Node2D_property_skew>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_skew**\ (\ value\: :ref:`float<class_float>`\ )
|
|
- :ref:`float<class_float>` **get_skew**\ (\ )
|
|
|
|
Se impostato su un valore diverso da zero, inclina il nodo in una direzione o nell'altra. Può essere utilizzato per effetti pseudo-3D. Vedi anche :ref:`global_skew<class_Node2D_property_global_skew>`.
|
|
|
|
\ **Nota:** L'inclinazione viene eseguita solo sull'asse X e *tra* la rotazione e il ridimensionamento.
|
|
|
|
\ **Nota:** Questa proprietà viene modificata nell'ispettore in gradi. Se è necessario utilizzare i gradi in uno script, usa ``skew = deg_to_rad(valore_in_gradi)``.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Node2D_property_transform:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`Transform2D<class_Transform2D>` **transform** :ref:`🔗<class_Node2D_property_transform>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_transform**\ (\ value\: :ref:`Transform2D<class_Transform2D>`\ )
|
|
- :ref:`Transform2D<class_Transform2D>` **get_transform**\ (\ )
|
|
|
|
il :ref:`Transform2D<class_Transform2D>` del nodo, relativo al nodo genitore di questo nodo. Vedi anche :ref:`global_transform<class_Node2D_property_global_transform>`.
|
|
|
|
.. rst-class:: classref-section-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-descriptions-group
|
|
|
|
Descrizioni dei metodi
|
|
--------------------------------------------
|
|
|
|
.. _class_Node2D_method_apply_scale:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **apply_scale**\ (\ ratio\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Node2D_method_apply_scale>`
|
|
|
|
Moltiplica la scala attuale per il vettore ``ratio``.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Node2D_method_get_angle_to:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`float<class_float>` **get_angle_to**\ (\ point\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Node2D_method_get_angle_to>`
|
|
|
|
Returns the angle between the node and the ``point`` in radians. See also :ref:`look_at()<class_Node2D_method_look_at>`.
|
|
|
|
\ `Illustration of the returned angle. <https://raw.githubusercontent.com/godotengine/godot-docs/master/img/node2d_get_angle_to.png>`__
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Node2D_method_get_relative_transform_to_parent:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Transform2D<class_Transform2D>` **get_relative_transform_to_parent**\ (\ parent\: :ref:`Node<class_Node>`\ ) |const| :ref:`🔗<class_Node2D_method_get_relative_transform_to_parent>`
|
|
|
|
Restituisce il :ref:`Transform2D<class_Transform2D>` relativo al nodo padre di questo nodo.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Node2D_method_global_translate:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **global_translate**\ (\ offset\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Node2D_method_global_translate>`
|
|
|
|
Aggiunge il vettore ``offset`` alla posizione globale del nodo.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Node2D_method_look_at:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **look_at**\ (\ point\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Node2D_method_look_at>`
|
|
|
|
Rotates the node so that its local +X axis points towards the ``point``, which is expected to use global coordinates. This method is a combination of both :ref:`rotate()<class_Node2D_method_rotate>` and :ref:`get_angle_to()<class_Node2D_method_get_angle_to>`.
|
|
|
|
\ ``point`` should not be the same as the node's position, otherwise the node always looks to the right.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Node2D_method_move_local_x:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **move_local_x**\ (\ delta\: :ref:`float<class_float>`, scaled\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_Node2D_method_move_local_x>`
|
|
|
|
Applies a local translation on the node's X axis with the amount specified in ``delta``. If ``scaled`` is ``false``, normalizes the movement to occur independently of the node's :ref:`scale<class_Node2D_property_scale>`.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Node2D_method_move_local_y:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **move_local_y**\ (\ delta\: :ref:`float<class_float>`, scaled\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_Node2D_method_move_local_y>`
|
|
|
|
Applies a local translation on the node's Y axis with the amount specified in ``delta``. If ``scaled`` is ``false``, normalizes the movement to occur independently of the node's :ref:`scale<class_Node2D_property_scale>`.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Node2D_method_rotate:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **rotate**\ (\ radians\: :ref:`float<class_float>`\ ) :ref:`🔗<class_Node2D_method_rotate>`
|
|
|
|
Applies a rotation to the node, in radians, starting from its current rotation. This is equivalent to ``rotation += radians``.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Node2D_method_to_global:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Vector2<class_Vector2>` **to_global**\ (\ local_point\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Node2D_method_to_global>`
|
|
|
|
Trasforma la posizione locale fornita in una posizione nello spazio di coordinate globali. L'input dovrebbe essere locale rispetto al **Node2D** su cui viene chiamato. Ad esempio, applicando questo metodo alle posizioni dei nodi figli, le loro posizioni saranno trasformate correttamente nello spazio di coordinate globali, ma applicandolo alla posizione del nodo stesso si otterrà un risultato non corretto, poiché incorporerà la trasformazione del nodo stesso nella sua posizione globale.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Node2D_method_to_local:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Vector2<class_Vector2>` **to_local**\ (\ global_point\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Node2D_method_to_local>`
|
|
|
|
Trasforma la posizione globale fornita in una posizione nello spazio delle coordinate locali. L'output sarà locale rispetto al **Node2D** su cui viene chiamato. Ad esempio, è appropriato per determinare le posizioni dei nodi figli, ma non è appropriato per determinare la propria posizione rispetto al proprio genitore.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Node2D_method_translate:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **translate**\ (\ offset\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Node2D_method_translate>`
|
|
|
|
Translates the node by the given ``offset`` in local coordinates. This is equivalent to ``position += offset``.
|
|
|
|
.. |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.)`
|