:github_url: hide .. _class_Transform3D: Transform3D =========== Una matrice 3×4 che rappresenta una trasformazione 3D. .. rst-class:: classref-introduction-group Descrizione ---------------------- Il tipo di :ref:`Variant` integrato **Transform3D** è una matrice 3×4 che rappresenta una trasformazione nello spazio 3D. Contiene una :ref:`Basis`, che da sola può rappresentare rotazione, scala e inclinazione. Inoltre, combinata con la sua :ref:`origin`, la trasformazione può anche rappresentare una traslazione. Per un'introduzione generale, consulta il tutorial :doc:`Matrici e trasformazioni <../tutorials/math/matrices_and_transforms>`. \ **Nota:** Godot utilizza un `sistema di coordinate destrorso `__, che è uno standard comune. Per le direzioni, la convenzione per i tipi integrati come :ref:`Camera3D` prevede che -Z punti in avanti (+X è destra, +Y è su +Z è indietro). Altri oggetti possono utilizzare convenzioni di direzione diverse. Per ulteriori informazioni, consulta il tutorial `Convenzioni sulla direzione delle risorse 3D <../tutorials/assets_pipeline/importing_3d_scenes/model_export_considerations.html#d-asset-direction-conventions>`__. .. note:: Ci sono differenze sostanziali quando si usa questa API con C#. Vedi :ref:`doc_c_sharp_differences` per maggiori informazioni. .. rst-class:: classref-introduction-group Tutorial ---------------- - :doc:`Indice della documentazione di matematica <../tutorials/math/index>` - :doc:`Le matrici e le trasformazioni <../tutorials/math/matrices_and_transforms>` - :doc:`Utilizzare le trasformazioni 3D <../tutorials/3d/using_transforms>` - `Demo di trasformazione di matrice `__ - `Demo di gioco piattaforme 3D `__ - `Demo di gioco 2.5D `__ .. rst-class:: classref-reftable-group Proprietà ------------------ .. table:: :widths: auto +-------------------------------+--------------------------------------------------+--------------------------------------+ | :ref:`Basis` | :ref:`basis` | ``Basis(1, 0, 0, 0, 1, 0, 0, 0, 1)`` | +-------------------------------+--------------------------------------------------+--------------------------------------+ | :ref:`Vector3` | :ref:`origin` | ``Vector3(0, 0, 0)`` | +-------------------------------+--------------------------------------------------+--------------------------------------+ .. rst-class:: classref-reftable-group Costruttori ---------------------- .. table:: :widths: auto +---------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Transform3D` | :ref:`Transform3D`\ (\ ) | +---------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Transform3D` | :ref:`Transform3D`\ (\ from\: :ref:`Transform3D`\ ) | +---------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Transform3D` | :ref:`Transform3D`\ (\ basis\: :ref:`Basis`, origin\: :ref:`Vector3`\ ) | +---------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Transform3D` | :ref:`Transform3D`\ (\ from\: :ref:`Projection`\ ) | +---------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Transform3D` | :ref:`Transform3D`\ (\ x_axis\: :ref:`Vector3`, y_axis\: :ref:`Vector3`, z_axis\: :ref:`Vector3`, origin\: :ref:`Vector3`\ ) | +---------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ .. rst-class:: classref-reftable-group Metodi ------------ .. table:: :widths: auto +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Transform3D` | :ref:`affine_inverse`\ (\ ) |const| | +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Transform3D` | :ref:`interpolate_with`\ (\ xform\: :ref:`Transform3D`, weight\: :ref:`float`\ ) |const| | +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Transform3D` | :ref:`inverse`\ (\ ) |const| | +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`is_equal_approx`\ (\ xform\: :ref:`Transform3D`\ ) |const| | +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`is_finite`\ (\ ) |const| | +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Transform3D` | :ref:`looking_at`\ (\ target\: :ref:`Vector3`, up\: :ref:`Vector3` = Vector3(0, 1, 0), use_model_front\: :ref:`bool` = false\ ) |const| | +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Transform3D` | :ref:`orthonormalized`\ (\ ) |const| | +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Transform3D` | :ref:`rotated`\ (\ axis\: :ref:`Vector3`, angle\: :ref:`float`\ ) |const| | +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Transform3D` | :ref:`rotated_local`\ (\ axis\: :ref:`Vector3`, angle\: :ref:`float`\ ) |const| | +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Transform3D` | :ref:`scaled`\ (\ scale\: :ref:`Vector3`\ ) |const| | +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Transform3D` | :ref:`scaled_local`\ (\ scale\: :ref:`Vector3`\ ) |const| | +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Transform3D` | :ref:`translated`\ (\ offset\: :ref:`Vector3`\ ) |const| | +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Transform3D` | :ref:`translated_local`\ (\ offset\: :ref:`Vector3`\ ) |const| | +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ .. rst-class:: classref-reftable-group Operatori ------------------ .. table:: :widths: auto +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`operator !=`\ (\ right\: :ref:`Transform3D`\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`AABB` | :ref:`operator *`\ (\ right\: :ref:`AABB`\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedVector3Array` | :ref:`operator *`\ (\ right\: :ref:`PackedVector3Array`\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Plane` | :ref:`operator *`\ (\ right\: :ref:`Plane`\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Transform3D` | :ref:`operator *`\ (\ right\: :ref:`Transform3D`\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Vector3` | :ref:`operator *`\ (\ right\: :ref:`Vector3`\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Transform3D` | :ref:`operator *`\ (\ right\: :ref:`float`\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Transform3D` | :ref:`operator *`\ (\ right\: :ref:`int`\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Transform3D` | :ref:`operator /`\ (\ right\: :ref:`float`\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Transform3D` | :ref:`operator /`\ (\ right\: :ref:`int`\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`operator ==`\ (\ right\: :ref:`Transform3D`\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+ .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Costanti ---------------- .. _class_Transform3D_constant_IDENTITY: .. rst-class:: classref-constant **IDENTITY** = ``Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0)`` :ref:`🔗` Il **Transform3D** di identità. Questa è una base senza rotazione, senza inclinazione, e con una scala pari a :ref:`Vector3.ONE`. La sua :ref:`basis` è uguale a :ref:`Basis.IDENTITY`. Ciò significa anche che: - La sua :ref:`Basis.x` punta a destra (:ref:`Vector3.RIGHT`); - La sua :ref:`Basis.y` punta in alto (:ref:`Vector3.UP`); - La sua :ref:`Basis.z` punta indietro (:ref:`Vector3.BACK`). :: var transform = Transform3D.IDENTITY var basis = transform.basis print("| X | Y | Z | Origine") print("| %.f | %.f | %.f | %.f" % [basis.x.x, basis.y.x, basis.z.x, transform.origin.x]) print("| %.f | %.f | %.f | %.f" % [basis.x.y, basis.y.y, basis.z.y, transform.origin.y]) print("| %.f | %.f | %.f | %.f" % [basis.x.z, basis.y.z, basis.z.z, transform.origin.z]) # Stampa: # | X | Y | Z | Origine # | 1 | 0 | 0 | 0 # | 0 | 1 | 0 | 0 # | 0 | 0 | 1 | 0 Se un :ref:`Vector2`, un :ref:`AABB`, un :ref:`Plane`, un :ref:`PackedVector3Array` o un altro **Transform3D** viene trasformato (moltiplicato) per questa costante, non si verifica alcuna trasformazione. \ **Nota:** In GDScript, questa costante è identica alla creazione di un :ref:`Transform3D` senza alcun argomento. Questa costante può essere usata per rendere il codice più chiaro e per coerenza con C#. .. _class_Transform3D_constant_FLIP_X: .. rst-class:: classref-constant **FLIP_X** = ``Transform3D(-1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0)`` :ref:`🔗` **Transform3D** con specchiatura applicata perpendicolarmente al piano YZ. La sua :ref:`basis` è uguale a :ref:`Basis.FLIP_X`. .. _class_Transform3D_constant_FLIP_Y: .. rst-class:: classref-constant **FLIP_Y** = ``Transform3D(1, 0, 0, 0, -1, 0, 0, 0, 1, 0, 0, 0)`` :ref:`🔗` **Transform3D** con specchiatura applicata perpendicolarmente al piano XZ . La sua :ref:`basis` è uguale a :ref:`Basis.FLIP_Y`. .. _class_Transform3D_constant_FLIP_Z: .. rst-class:: classref-constant **FLIP_Z** = ``Transform3D(1, 0, 0, 0, 1, 0, 0, 0, -1, 0, 0, 0)`` :ref:`🔗` **Transform3D** con specchiatura applicata perpendicolarmente al piano XY. La sua :ref:`basis` è uguale a :ref:`Basis.FLIP_Z`. .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Descrizioni delle proprietà ------------------------------------------------------ .. _class_Transform3D_property_basis: .. rst-class:: classref-property :ref:`Basis` **basis** = ``Basis(1, 0, 0, 0, 1, 0, 0, 0, 1)`` :ref:`🔗` La :ref:`Basis` di questa trasformazione. È composta da 3 assi (:ref:`Basis.x`, :ref:`Basis.y` e :ref:`Basis.z`). Insieme, rappresentano la rotazione, la scala e l'inclinazione della trasformazione. .. rst-class:: classref-item-separator ---- .. _class_Transform3D_property_origin: .. rst-class:: classref-property :ref:`Vector3` **origin** = ``Vector3(0, 0, 0)`` :ref:`🔗` L'offset di traslazione di questa trasformazione. Nello spazio 3D, questo può essere visto come la posizione. .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Descrizioni dei costruttori ------------------------------------------------------ .. _class_Transform3D_constructor_Transform3D: .. rst-class:: classref-constructor :ref:`Transform3D` **Transform3D**\ (\ ) :ref:`🔗` Costruisce un **Transform3D** identico a :ref:`IDENTITY`. \ **Nota:** In C#, costruisce un **Transform3D** con il suo :ref:`origin` e tutti i componenti della sua :ref:`basis` impostati su :ref:`Vector2.ZERO`. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`Transform3D` **Transform3D**\ (\ from\: :ref:`Transform3D`\ ) Costruisce un **Transform3D** come copia del **Transform3D** specificato. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`Transform3D` **Transform3D**\ (\ basis\: :ref:`Basis`, origin\: :ref:`Vector3`\ ) Costruisce un **Transform3D** da un :ref:`Basis` e :ref:`Vector3`. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`Transform3D` **Transform3D**\ (\ from\: :ref:`Projection`\ ) Costruisce un **Transform3D** da una :ref:`Projection`. Poiché **Transform3D** è una matrice 3×4 e :ref:`Projection` è una matrice 4×4, questa operazione scarta l'ultima riga della matrice di proiezione (``from.x.w``, ``from.y.w``, ``from.z.w`` e ``from.w.w`` non sono inclusi nella nuova trasformazione). .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`Transform3D` **Transform3D**\ (\ x_axis\: :ref:`Vector3`, y_axis\: :ref:`Vector3`, z_axis\: :ref:`Vector3`, origin\: :ref:`Vector3`\ ) Costruisce un **Transform3D** da quattro valori :ref:`Vector3` (chiamati anche colonne di matrice). I primi tre argomenti sono gli assi della :ref:`basis` (:ref:`Basis.x`, :ref:`Basis.y` e :ref:`Basis.z`). .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Descrizioni dei metodi -------------------------------------------- .. _class_Transform3D_method_affine_inverse: .. rst-class:: classref-method :ref:`Transform3D` **affine_inverse**\ (\ ) |const| :ref:`🔗` Restituisce la versione invertita di questa trasformazione. A differenza di :ref:`inverse()`, questo metodo funziona con quasi ogni :ref:`basis`, comprese quelle non uniformi, ma è più lento. Vedi anche :ref:`Basis.inverse()`. \ **Nota:** Affinché questo metodo restituisca correttamente, la :ref:`basis` della trasformazione deve avere un determinante che non sia esattamente ``0.0`` (vedi :ref:`Basis.determinant()`). .. rst-class:: classref-item-separator ---- .. _class_Transform3D_method_interpolate_with: .. rst-class:: classref-method :ref:`Transform3D` **interpolate_with**\ (\ xform\: :ref:`Transform3D`, weight\: :ref:`float`\ ) |const| :ref:`🔗` Restituisce il risultato dell'interpolazione lineare tra questa trasformazione e ``xform`` per il peso ``weight``. \ ``weight`` dovrebbe essere compreso tra ``0.0`` e ``1.0`` (inclusi). I valori al di fuori di questo intervallo sono consentiti e possono essere utilizzati per eseguire un'*estrapolazione*. .. rst-class:: classref-item-separator ---- .. _class_Transform3D_method_inverse: .. rst-class:: classref-method :ref:`Transform3D` **inverse**\ (\ ) |const| :ref:`🔗` Restituisce la `versione invertita di questa trasformazione `__. Vedi anche :ref:`Basis.inverse()`. \ **Nota:** Affinché questo metodo restituisca correttamente, la :ref:`basis` della trasformazione deve essere *ortonormale* (vedi :ref:`orthonormalized()`). Ciò significa che la base dovrebbe rappresentare solo una rotazione. In caso contrario, usa invece :ref:`affine_inverse()`. .. rst-class:: classref-item-separator ---- .. _class_Transform3D_method_is_equal_approx: .. rst-class:: classref-method :ref:`bool` **is_equal_approx**\ (\ xform\: :ref:`Transform3D`\ ) |const| :ref:`🔗` Restituisce ``true`` se questa trasformazione e ``xform`` sono approssimativamente uguali, chiamando :ref:`@GlobalScope.is_equal_approx()` su ogni componente. .. rst-class:: classref-item-separator ---- .. _class_Transform3D_method_is_finite: .. rst-class:: classref-method :ref:`bool` **is_finite**\ (\ ) |const| :ref:`🔗` Restituisce ``true`` se questa trasformazione è finita, chiamando :ref:`@GlobalScope.is_finite()` su ogni componente. .. rst-class:: classref-item-separator ---- .. _class_Transform3D_method_looking_at: .. rst-class:: classref-method :ref:`Transform3D` **looking_at**\ (\ target\: :ref:`Vector3`, up\: :ref:`Vector3` = Vector3(0, 1, 0), use_model_front\: :ref:`bool` = false\ ) |const| :ref:`🔗` Restituisce una copia di questa trasformazione ruotata in modo che l'asse anteriore (-Z) punti verso la posizione ``target``. L'asse superiore (+Y) punta il più vicino possibile al vettore ``up``, pur rimanendo perpendicolare all'asse anteriore. La trasformazione risultante è ortonormalizzata. Le informazioni esistenti sulla rotazione, scala e inclinazione della trasformazione originale vengono scartate. I vettori ``target`` e ``up`` non possono essere zero, non possono essere paralleli tra loro e sono definiti nello spazio globale/padre. Se ``use_model_front`` è ``true``, l'asse +Z (avanti per gli asset) viene trattato come anteriore (implica che +X sia a sinistra) e punta verso la posizione ``target``. Come predefinito, l'asse -Z (avanti per la telecamera) viene trattato come anteriore (implica che +X sia a destra). .. rst-class:: classref-item-separator ---- .. _class_Transform3D_method_orthonormalized: .. rst-class:: classref-method :ref:`Transform3D` **orthonormalized**\ (\ ) |const| :ref:`🔗` Restituisce una copia di questa trasformazione con la sua :ref:`basis` ortonormalizzata. Una base ortonormale è sia *ortogonale* (gli assi sono perpendicolari tra loro) sia *normalizzata* (gli assi hanno una lunghezza di ``1.0``), il che significa anche che può rappresentare solo una rotazione. Vedi anche :ref:`Basis.orthonormalized()`. .. rst-class:: classref-item-separator ---- .. _class_Transform3D_method_rotated: .. rst-class:: classref-method :ref:`Transform3D` **rotated**\ (\ axis\: :ref:`Vector3`, angle\: :ref:`float`\ ) |const| :ref:`🔗` Restituisce una copia di questa trasformazione ruotata attorno all'asse ``axis`` dell'angolo ``angle`` (in radianti). L'asse ``axis`` deve essere un vettore normalizzato (vedi :ref:`Vector3.normalized()`). Se ``angle`` è positivo, la base viene ruotata in senso antiorario attorno l'asse. Questo metodo è una versione ottimizzata della moltiplicazione della trasformazione fornita ``X`` con una corrispondente trasformazione di rotazione ``R`` da sinistra, ovvero ``R * X``. Ciò può essere visto come una trasformazione rispetto alla struttura globale/padre. .. rst-class:: classref-item-separator ---- .. _class_Transform3D_method_rotated_local: .. rst-class:: classref-method :ref:`Transform3D` **rotated_local**\ (\ axis\: :ref:`Vector3`, angle\: :ref:`float`\ ) |const| :ref:`🔗` Restituisce una copia di questa trasformazione ruotata attorno all'asse ``axis`` dell'angolo ``angle`` (in radianti). L'asse ``axis`` deve essere un vettore normalizzato nel sistema di coordinate locali della trasformazione. Ad esempio, per ruotare attorno all'asse X locale, usa :ref:`Vector3.RIGHT`. Questo metodo è una versione ottimizzata della moltiplicazione della trasformazione fornita ``X`` con una corrispondente trasformazione di rotazione ``R`` da destra, ovvero ``X * R``. Questo può essere visto come una trasformazione rispetto alla struttura locale. .. rst-class:: classref-item-separator ---- .. _class_Transform3D_method_scaled: .. rst-class:: classref-method :ref:`Transform3D` **scaled**\ (\ scale\: :ref:`Vector3`\ ) |const| :ref:`🔗` Restituisce una copia di questa trasformazione scalata dal fattore ``scale`` specificato. Questo metodo è una versione ottimizzata della moltiplicazione della trasformazione fornita ``X`` con una trasformazione di scala corrispondente ``S`` da sinistra, ovvero ``S * X``. Questo può essere visto come una trasformazione rispetto al frame globale/padre. .. rst-class:: classref-item-separator ---- .. _class_Transform3D_method_scaled_local: .. rst-class:: classref-method :ref:`Transform3D` **scaled_local**\ (\ scale\: :ref:`Vector3`\ ) |const| :ref:`🔗` Restituisce una copia di questa trasformazione scalata dal fattore ``scale`` specificato. Questo metodo è una versione ottimizzata della moltiplicazione della trasformazione fornita ``X`` con una trasformazione di scala corrispondente ``S`` da destra, ovvero ``X * S``. Questo può essere visto come una trasformazione rispetto al frame locale. .. rst-class:: classref-item-separator ---- .. _class_Transform3D_method_translated: .. rst-class:: classref-method :ref:`Transform3D` **translated**\ (\ offset\: :ref:`Vector3`\ ) |const| :ref:`🔗` Restituisce una copia di questa trasformazione traslata dal valore di ``offset``. Questo metodo è una versione ottimizzata della moltiplicazione della trasformazione fornita ``X`` con una corrispondente trasformazione di traslazione ``T`` da sinistra, ovvero ``T * X``. Questo può essere visto come una trasformazione rispetto al frame globale/padre. .. rst-class:: classref-item-separator ---- .. _class_Transform3D_method_translated_local: .. rst-class:: classref-method :ref:`Transform3D` **translated_local**\ (\ offset\: :ref:`Vector3`\ ) |const| :ref:`🔗` Restituisce una copia di questa trasformazione traslata dal valore di ``offset``. Questo metodo è una versione ottimizzata della moltiplicazione della trasformazione fornita ``X`` con una corrispondente trasformazione di traslazione ``T`` da destra, ovvero ``X * T``. Questo può essere visto come una trasformazione rispetto al frame locale. .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Descrizioni degli operatori ------------------------------------------------------ .. _class_Transform3D_operator_neq_Transform3D: .. rst-class:: classref-operator :ref:`bool` **operator !=**\ (\ right\: :ref:`Transform3D`\ ) :ref:`🔗` Restituisce ``true`` se i componenti di entrambe le trasformazioni non sono uguali, rispettivamente. \ **Note:** A causa di errori di precisione per virgola mobile, considera invece utilizzare :ref:`is_equal_approx()`, che è più affidabile. .. rst-class:: classref-item-separator ---- .. _class_Transform3D_operator_mul_AABB: .. rst-class:: classref-operator :ref:`AABB` **operator ***\ (\ right\: :ref:`AABB`\ ) :ref:`🔗` Trasforma (moltiplica) l':ref:`AABB` per questa matrice di trasformazione. .. rst-class:: classref-item-separator ---- .. _class_Transform3D_operator_mul_PackedVector3Array: .. rst-class:: classref-operator :ref:`PackedVector3Array` **operator ***\ (\ right\: :ref:`PackedVector3Array`\ ) :ref:`🔗` Trasforma (moltiplica) ogni elemento :ref:`Vector3` del :ref:`PackedVector3Array` specificato per questa matrice di trasformazione. Su array più grandi, questa operazione è molto più veloce della trasformazione di ogni singolo :ref:`Vector3`. .. rst-class:: classref-item-separator ---- .. _class_Transform3D_operator_mul_Plane: .. rst-class:: classref-operator :ref:`Plane` **operator ***\ (\ right\: :ref:`Plane`\ ) :ref:`🔗` Trasforma (moltiplica) il :ref:`Plane` per questa matrice di trasformazione. .. rst-class:: classref-item-separator ---- .. _class_Transform3D_operator_mul_Transform3D: .. rst-class:: classref-operator :ref:`Transform3D` **operator ***\ (\ right\: :ref:`Transform3D`\ ) :ref:`🔗` Trasforma (moltiplica) questa trasformazione per la trasformazione ``right``. Questa è l'operazione eseguita tra i nodi :ref:`Node3D` genitore e figlio. \ **Nota:** Se devi modificare solo un attributo di questa trasformazione, considera di usare uno dei seguenti metodi: - Per la traduzione, vedi :ref:`translated()` o :ref:`translated_local()`. - Per la rotazione, vedi :ref:`rotated()` o :ref:`rotated_local()`. - Per la scala, vedi :ref:`scaled()` o :ref:`scaled_local()`. .. rst-class:: classref-item-separator ---- .. _class_Transform3D_operator_mul_Vector3: .. rst-class:: classref-operator :ref:`Vector3` **operator ***\ (\ right\: :ref:`Vector3`\ ) :ref:`🔗` Trasforma (moltiplica) il :ref:`Vector3` per questa matrice di trasformazione. .. rst-class:: classref-item-separator ---- .. _class_Transform3D_operator_mul_float: .. rst-class:: classref-operator :ref:`Transform3D` **operator ***\ (\ right\: :ref:`float`\ ) :ref:`🔗` Moltiplica tutti i componenti del **Transform3D** per il :ref:`float` indicato, incluso l':ref:`origin`. Ciò influenza la scala della trasformazione in modo uniforme, ridimensionando la :ref:`basis`. .. rst-class:: classref-item-separator ---- .. _class_Transform3D_operator_mul_int: .. rst-class:: classref-operator :ref:`Transform3D` **operator ***\ (\ right\: :ref:`int`\ ) :ref:`🔗` Moltiplica tutti i componenti del **Transform3D** per l':ref:`int` indicato, incluso l':ref:`origin`. Ciò influenza la scala della trasformazione in modo uniforme, ridimensionando la :ref:`basis`. .. rst-class:: classref-item-separator ---- .. _class_Transform3D_operator_div_float: .. rst-class:: classref-operator :ref:`Transform3D` **operator /**\ (\ right\: :ref:`float`\ ) :ref:`🔗` Divide tutti i componenti del **Transform3D** per il :ref:`float` indicato, incluso l':ref:`origin`. Ciò influenza la scala della trasformazione in modo uniforme, ridimensionando la :ref:`basis`. .. rst-class:: classref-item-separator ---- .. _class_Transform3D_operator_div_int: .. rst-class:: classref-operator :ref:`Transform3D` **operator /**\ (\ right\: :ref:`int`\ ) :ref:`🔗` Divide tutti i componenti del **Transform3D** per l':ref:`int` indicato, incluso l':ref:`origin`. Ciò influenza la scala della trasformazione in modo uniforme, ridimensionando la :ref:`basis`. .. rst-class:: classref-item-separator ---- .. _class_Transform3D_operator_eq_Transform3D: .. rst-class:: classref-operator :ref:`bool` **operator ==**\ (\ right\: :ref:`Transform3D`\ ) :ref:`🔗` Restituisce ``true`` se i componenti di entrambe le trasformazioni non sono esattamente uguali. \ **Note:** A causa di errori di precisione per virgola mobile, considera invece utilizzare :ref:`is_equal_approx()`, che è più affidabile. .. |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.)`