mirror of
https://github.com/godotengine/godot-docs-l10n.git
synced 2025-12-31 09:49:22 +03:00
248 lines
14 KiB
ReStructuredText
248 lines
14 KiB
ReStructuredText
:github_url: hide
|
|
|
|
.. _class_Parallax2D:
|
|
|
|
Parallax2D
|
|
==========
|
|
|
|
**Eredita:** :ref:`Node2D<class_Node2D>` **<** :ref:`CanvasItem<class_CanvasItem>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
|
|
|
|
Un nodo usato per creare uno sfondo a scorrimento parallasse.
|
|
|
|
.. rst-class:: classref-introduction-group
|
|
|
|
Descrizione
|
|
----------------------
|
|
|
|
Un **Parallax2D** serve per creare un effetto parallasse. Può muoversi a una velocità diversa rispetto al movimento della telecamera tramite :ref:`scroll_scale<class_Parallax2D_property_scroll_scale>`. Ciò crea un'illusione di profondità in un gioco 2D. Se si desidera lo scorrimento manuale, la posizione della :ref:`Camera2D<class_Camera2D>` può essere ignorata con :ref:`ignore_camera_scroll<class_Parallax2D_property_ignore_camera_scroll>`.
|
|
|
|
\ **Nota:** Qualsiasi modifica alla posizione di questo nodo apportata dopo che è entrato nell'albero di scena verrà ignorata se :ref:`ignore_camera_scroll<class_Parallax2D_property_ignore_camera_scroll>` è ``false`` o se :ref:`screen_offset<class_Parallax2D_property_screen_offset>` viene modificato.
|
|
|
|
.. rst-class:: classref-introduction-group
|
|
|
|
Tutorial
|
|
----------------
|
|
|
|
- :doc:`Parallasse 2D <../tutorials/2d/2d_parallax>`
|
|
|
|
.. rst-class:: classref-reftable-group
|
|
|
|
Proprietà
|
|
------------------
|
|
|
|
.. table::
|
|
:widths: auto
|
|
|
|
+---------------------------------------------------------------------+-----------------------------------------------------------------------------+-------------------------------------------------------------------------------+
|
|
| :ref:`Vector2<class_Vector2>` | :ref:`autoscroll<class_Parallax2D_property_autoscroll>` | ``Vector2(0, 0)`` |
|
|
+---------------------------------------------------------------------+-----------------------------------------------------------------------------+-------------------------------------------------------------------------------+
|
|
| :ref:`bool<class_bool>` | :ref:`follow_viewport<class_Parallax2D_property_follow_viewport>` | ``true`` |
|
|
+---------------------------------------------------------------------+-----------------------------------------------------------------------------+-------------------------------------------------------------------------------+
|
|
| :ref:`bool<class_bool>` | :ref:`ignore_camera_scroll<class_Parallax2D_property_ignore_camera_scroll>` | ``false`` |
|
|
+---------------------------------------------------------------------+-----------------------------------------------------------------------------+-------------------------------------------------------------------------------+
|
|
| :ref:`Vector2<class_Vector2>` | :ref:`limit_begin<class_Parallax2D_property_limit_begin>` | ``Vector2(-10000000, -10000000)`` |
|
|
+---------------------------------------------------------------------+-----------------------------------------------------------------------------+-------------------------------------------------------------------------------+
|
|
| :ref:`Vector2<class_Vector2>` | :ref:`limit_end<class_Parallax2D_property_limit_end>` | ``Vector2(10000000, 10000000)`` |
|
|
+---------------------------------------------------------------------+-----------------------------------------------------------------------------+-------------------------------------------------------------------------------+
|
|
| :ref:`PhysicsInterpolationMode<enum_Node_PhysicsInterpolationMode>` | physics_interpolation_mode | ``2`` (overrides :ref:`Node<class_Node_property_physics_interpolation_mode>`) |
|
|
+---------------------------------------------------------------------+-----------------------------------------------------------------------------+-------------------------------------------------------------------------------+
|
|
| :ref:`Vector2<class_Vector2>` | :ref:`repeat_size<class_Parallax2D_property_repeat_size>` | ``Vector2(0, 0)`` |
|
|
+---------------------------------------------------------------------+-----------------------------------------------------------------------------+-------------------------------------------------------------------------------+
|
|
| :ref:`int<class_int>` | :ref:`repeat_times<class_Parallax2D_property_repeat_times>` | ``1`` |
|
|
+---------------------------------------------------------------------+-----------------------------------------------------------------------------+-------------------------------------------------------------------------------+
|
|
| :ref:`Vector2<class_Vector2>` | :ref:`screen_offset<class_Parallax2D_property_screen_offset>` | ``Vector2(0, 0)`` |
|
|
+---------------------------------------------------------------------+-----------------------------------------------------------------------------+-------------------------------------------------------------------------------+
|
|
| :ref:`Vector2<class_Vector2>` | :ref:`scroll_offset<class_Parallax2D_property_scroll_offset>` | ``Vector2(0, 0)`` |
|
|
+---------------------------------------------------------------------+-----------------------------------------------------------------------------+-------------------------------------------------------------------------------+
|
|
| :ref:`Vector2<class_Vector2>` | :ref:`scroll_scale<class_Parallax2D_property_scroll_scale>` | ``Vector2(1, 1)`` |
|
|
+---------------------------------------------------------------------+-----------------------------------------------------------------------------+-------------------------------------------------------------------------------+
|
|
|
|
.. rst-class:: classref-section-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-descriptions-group
|
|
|
|
Descrizioni delle proprietà
|
|
------------------------------------------------------
|
|
|
|
.. _class_Parallax2D_property_autoscroll:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`Vector2<class_Vector2>` **autoscroll** = ``Vector2(0, 0)`` :ref:`🔗<class_Parallax2D_property_autoscroll>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_autoscroll**\ (\ value\: :ref:`Vector2<class_Vector2>`\ )
|
|
- :ref:`Vector2<class_Vector2>` **get_autoscroll**\ (\ )
|
|
|
|
La velocità alla quale lo scostamento scorre automaticamente, in pixel al secondo.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Parallax2D_property_follow_viewport:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`bool<class_bool>` **follow_viewport** = ``true`` :ref:`🔗<class_Parallax2D_property_follow_viewport>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_follow_viewport**\ (\ value\: :ref:`bool<class_bool>`\ )
|
|
- :ref:`bool<class_bool>` **get_follow_viewport**\ (\ )
|
|
|
|
Se ``true``, questo **Parallax2D** è scostato dalla posizione della telecamera attuale. Se **Parallax2D** è in un :ref:`CanvasLayer<class_CanvasLayer>` separato dalla telecamera attuale, potrebbe essere opportuno abbinare il valore con :ref:`CanvasLayer.follow_viewport_enabled<class_CanvasLayer_property_follow_viewport_enabled>`.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Parallax2D_property_ignore_camera_scroll:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`bool<class_bool>` **ignore_camera_scroll** = ``false`` :ref:`🔗<class_Parallax2D_property_ignore_camera_scroll>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_ignore_camera_scroll**\ (\ value\: :ref:`bool<class_bool>`\ )
|
|
- :ref:`bool<class_bool>` **is_ignore_camera_scroll**\ (\ )
|
|
|
|
Se ``true``, la posizione del **Parallax2D** non è influenzata dalla posizione della telecamera.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Parallax2D_property_limit_begin:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`Vector2<class_Vector2>` **limit_begin** = ``Vector2(-10000000, -10000000)`` :ref:`🔗<class_Parallax2D_property_limit_begin>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_limit_begin**\ (\ value\: :ref:`Vector2<class_Vector2>`\ )
|
|
- :ref:`Vector2<class_Vector2>` **get_limit_begin**\ (\ )
|
|
|
|
Limiti in alto a sinistra per l'inizio dello scorrimento. Se la telecamera è al di fuori di questo limite, il **Parallax2D** smette di scorrere. Deve essere inferiore a :ref:`limit_end<class_Parallax2D_property_limit_end>` meno le dimensioni della viewport per funzionare.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Parallax2D_property_limit_end:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`Vector2<class_Vector2>` **limit_end** = ``Vector2(10000000, 10000000)`` :ref:`🔗<class_Parallax2D_property_limit_end>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_limit_end**\ (\ value\: :ref:`Vector2<class_Vector2>`\ )
|
|
- :ref:`Vector2<class_Vector2>` **get_limit_end**\ (\ )
|
|
|
|
Limiti in alto a sinistra per la fine dello scorrimento. Se la telecamera è al di fuori di questo limite, il **Parallax2D** smette di scorrere. Deve essere superiore a :ref:`limit_begin<class_Parallax2D_property_limit_begin>` combinato con le dimensioni della viewport per funzionare.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Parallax2D_property_repeat_size:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`Vector2<class_Vector2>` **repeat_size** = ``Vector2(0, 0)`` :ref:`🔗<class_Parallax2D_property_repeat_size>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_repeat_size**\ (\ value\: :ref:`Vector2<class_Vector2>`\ )
|
|
- :ref:`Vector2<class_Vector2>` **get_repeat_size**\ (\ )
|
|
|
|
Ripete la :ref:`Texture2D<class_Texture2D>` di ciascuno dei figli di questo nodo e li scosta con questo valore. Durante lo scorrimento, la posizione del nodo si ripete, dando l'illusione di uno sfondo a scorrimento infinito se i valori sono più grandi delle dimensioni dello schermo. Se un asse è impostato su ``0``, la :ref:`Texture2D<class_Texture2D>` non sarà ripetuta.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Parallax2D_property_repeat_times:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`int<class_int>` **repeat_times** = ``1`` :ref:`🔗<class_Parallax2D_property_repeat_times>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_repeat_times**\ (\ value\: :ref:`int<class_int>`\ )
|
|
- :ref:`int<class_int>` **get_repeat_times**\ (\ )
|
|
|
|
Sostituisce il numero di volte in cui la texture si ripete. Ogni copia della texture si sparge uniformemente dall'originale dal fattore :ref:`repeat_size<class_Parallax2D_property_repeat_size>`. Utile quando si esegue lo zoom indietro con una telecamera.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Parallax2D_property_screen_offset:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`Vector2<class_Vector2>` **screen_offset** = ``Vector2(0, 0)`` :ref:`🔗<class_Parallax2D_property_screen_offset>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_screen_offset**\ (\ value\: :ref:`Vector2<class_Vector2>`\ )
|
|
- :ref:`Vector2<class_Vector2>` **get_screen_offset**\ (\ )
|
|
|
|
Lo scostamento utilizzato per scorrere questo **Parallax2D**. Questo valore è aggiornato automaticamente a meno che :ref:`ignore_camera_scroll<class_Parallax2D_property_ignore_camera_scroll>` non sia ``true``.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Parallax2D_property_scroll_offset:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`Vector2<class_Vector2>` **scroll_offset** = ``Vector2(0, 0)`` :ref:`🔗<class_Parallax2D_property_scroll_offset>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_scroll_offset**\ (\ value\: :ref:`Vector2<class_Vector2>`\ )
|
|
- :ref:`Vector2<class_Vector2>` **get_scroll_offset**\ (\ )
|
|
|
|
Lo scostamento del **Parallax2D**. Simile a :ref:`screen_offset<class_Parallax2D_property_screen_offset>` e :ref:`Node2D.position<class_Node2D_property_position>`, ma non sarà sovrascritto.
|
|
|
|
\ **Nota:** I valori si ripeteranno se :ref:`repeat_size<class_Parallax2D_property_repeat_size>` è impostato su un valore maggiore di ``0``.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Parallax2D_property_scroll_scale:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`Vector2<class_Vector2>` **scroll_scale** = ``Vector2(1, 1)`` :ref:`🔗<class_Parallax2D_property_scroll_scale>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_scroll_scale**\ (\ value\: :ref:`Vector2<class_Vector2>`\ )
|
|
- :ref:`Vector2<class_Vector2>` **get_scroll_scale**\ (\ )
|
|
|
|
Moltiplicatore per lo scostamento finale del **Parallax2D**. Può essere utilizzato per simulare la distanza dalla telecamera.
|
|
|
|
Ad esempio, un valore di ``1`` scorre alla stessa velocità della telecamera. Un valore maggiore di ``1`` scorre più velocemente, facendo apparire gli oggetti più vicini. Un valore minore di ``1`` scorre più lentamente, facendo apparire gli oggetti più lontani, e un valore di ``0`` ferma completamente gli oggetti.
|
|
|
|
.. |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.)`
|