godotengine/godot-docs-l10n
1
0
Fork 0
mirror of https://github.com/godotengine/godot-docs-l10n.git synced 2026-01-04 10:09:56 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
4.5
godot-docs-l10n/classes/fr/class_curve3d.rst

496 lines
34 KiB
ReStructuredText
Raw Permalink Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

:github_url: hide
.. _class_Curve3D:
Curve3D
=======
**Hérite de :** :ref:`Resource<class_Resource>` **<** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
Décrit une courbe de Bézier dans l’espace 3D.
.. rst-class:: classref-introduction-group
Description
-----------
Cette classe décrit une courbe de Bézier dans l'espace 3D. Elle est principalement utilisée pour donner une forme à un :ref:`Path3D<class_Path3D>`, mais peut être échantillonnée manuellement à d'autres fins.
Elle conserve un cache des points précalculés le long de la courbe, pour accélérer les calculs suivants.
.. rst-class:: classref-reftable-group
Propriétés
--------------------
.. table::
:widths: auto
+---------------------------+--------------------------------------------------------------------+-----------+
| :ref:`float<class_float>` | :ref:`bake_interval<class_Curve3D_property_bake_interval>` | ``0.2`` |
+---------------------------+--------------------------------------------------------------------+-----------+
| :ref:`bool<class_bool>` | :ref:`closed<class_Curve3D_property_closed>` | ``false`` |
+---------------------------+--------------------------------------------------------------------+-----------+
| :ref:`int<class_int>` | :ref:`point_count<class_Curve3D_property_point_count>` | ``0`` |
+---------------------------+--------------------------------------------------------------------+-----------+
| :ref:`bool<class_bool>` | :ref:`up_vector_enabled<class_Curve3D_property_up_vector_enabled>` | ``true`` |
+---------------------------+--------------------------------------------------------------------+-----------+
.. rst-class:: classref-reftable-group
Méthodes
----------------
.. table::
:widths: auto
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`add_point<class_Curve3D_method_add_point>`\ (\ position\: :ref:`Vector3<class_Vector3>`, in\: :ref:`Vector3<class_Vector3>` = Vector3(0, 0, 0), out\: :ref:`Vector3<class_Vector3>` = Vector3(0, 0, 0), index\: :ref:`int<class_int>` = -1\ ) |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`clear_points<class_Curve3D_method_clear_points>`\ (\ ) |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`get_baked_length<class_Curve3D_method_get_baked_length>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedVector3Array<class_PackedVector3Array>` | :ref:`get_baked_points<class_Curve3D_method_get_baked_points>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedFloat32Array<class_PackedFloat32Array>` | :ref:`get_baked_tilts<class_Curve3D_method_get_baked_tilts>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedVector3Array<class_PackedVector3Array>` | :ref:`get_baked_up_vectors<class_Curve3D_method_get_baked_up_vectors>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`get_closest_offset<class_Curve3D_method_get_closest_offset>`\ (\ to_point\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`get_closest_point<class_Curve3D_method_get_closest_point>`\ (\ to_point\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`get_point_in<class_Curve3D_method_get_point_in>`\ (\ idx\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`get_point_out<class_Curve3D_method_get_point_out>`\ (\ idx\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`get_point_position<class_Curve3D_method_get_point_position>`\ (\ idx\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`get_point_tilt<class_Curve3D_method_get_point_tilt>`\ (\ idx\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`remove_point<class_Curve3D_method_remove_point>`\ (\ idx\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`sample<class_Curve3D_method_sample>`\ (\ idx\: :ref:`int<class_int>`, t\: :ref:`float<class_float>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`sample_baked<class_Curve3D_method_sample_baked>`\ (\ offset\: :ref:`float<class_float>` = 0.0, cubic\: :ref:`bool<class_bool>` = false\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`sample_baked_up_vector<class_Curve3D_method_sample_baked_up_vector>`\ (\ offset\: :ref:`float<class_float>`, apply_tilt\: :ref:`bool<class_bool>` = false\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Transform3D<class_Transform3D>` | :ref:`sample_baked_with_rotation<class_Curve3D_method_sample_baked_with_rotation>`\ (\ offset\: :ref:`float<class_float>` = 0.0, cubic\: :ref:`bool<class_bool>` = false, apply_tilt\: :ref:`bool<class_bool>` = false\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`samplef<class_Curve3D_method_samplef>`\ (\ fofs\: :ref:`float<class_float>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_point_in<class_Curve3D_method_set_point_in>`\ (\ idx\: :ref:`int<class_int>`, position\: :ref:`Vector3<class_Vector3>`\ ) |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_point_out<class_Curve3D_method_set_point_out>`\ (\ idx\: :ref:`int<class_int>`, position\: :ref:`Vector3<class_Vector3>`\ ) |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_point_position<class_Curve3D_method_set_point_position>`\ (\ idx\: :ref:`int<class_int>`, position\: :ref:`Vector3<class_Vector3>`\ ) |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_point_tilt<class_Curve3D_method_set_point_tilt>`\ (\ idx\: :ref:`int<class_int>`, tilt\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedVector3Array<class_PackedVector3Array>` | :ref:`tessellate<class_Curve3D_method_tessellate>`\ (\ max_stages\: :ref:`int<class_int>` = 5, tolerance_degrees\: :ref:`float<class_float>` = 4\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedVector3Array<class_PackedVector3Array>` | :ref:`tessellate_even_length<class_Curve3D_method_tessellate_even_length>`\ (\ max_stages\: :ref:`int<class_int>` = 5, tolerance_length\: :ref:`float<class_float>` = 0.2\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descriptions des propriétés
------------------------------------------------------
.. _class_Curve3D_property_bake_interval:
.. rst-class:: classref-property
:ref:`float<class_float>` **bake_interval** = ``0.2`` :ref:`🔗<class_Curve3D_property_bake_interval>`
.. rst-class:: classref-property-setget
- |void| **set_bake_interval**\ (\ value\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_bake_interval**\ (\ )
La distance en unités entre deux points de cache adjacents. Le changement force le cache à être recalculé la prochaine fois que la fonction :ref:`get_baked_points()<class_Curve3D_method_get_baked_points>` ou :ref:`get_baked_length()<class_Curve3D_method_get_baked_length>` sera appelée. Plus la distance est petite, plus il y aura de points dans le cache, et plus ça utilisera de mémoire, à utiliser donc avec soin.
.. rst-class:: classref-item-separator
----
.. _class_Curve3D_property_closed:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **closed** = ``false`` :ref:`🔗<class_Curve3D_property_closed>`
.. rst-class:: classref-property-setget
- |void| **set_closed**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_closed**\ (\ )
Si ``true`` et que la courbe a plus de 2 points de contrôle, le dernier et le premier point seront connectés en une boucle.
.. rst-class:: classref-item-separator
----
.. _class_Curve3D_property_point_count:
.. rst-class:: classref-property
:ref:`int<class_int>` **point_count** = ``0`` :ref:`🔗<class_Curve3D_property_point_count>`
.. rst-class:: classref-property-setget
- |void| **set_point_count**\ (\ value\: :ref:`int<class_int>`\ )
- :ref:`int<class_int>` **get_point_count**\ (\ )
Le nombre de points décrivant la courbe.
.. rst-class:: classref-item-separator
----
.. _class_Curve3D_property_up_vector_enabled:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **up_vector_enabled** = ``true`` :ref:`🔗<class_Curve3D_property_up_vector_enabled>`
.. rst-class:: classref-property-setget
- |void| **set_up_vector_enabled**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_up_vector_enabled**\ (\ )
Si ``true``, la courbe pré-calcule les vecteurs utilisés pour l'orientation. Ceci est utilisé lorsque :ref:`PathFollow3D.rotation_mode<class_PathFollow3D_property_rotation_mode>` est défini à :ref:`PathFollow3D.ROTATION_ORIENTED<class_PathFollow3D_constant_ROTATION_ORIENTED>`. Le changer force le cache à être recalculé.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descriptions des méthodes
--------------------------------------------------
.. _class_Curve3D_method_add_point:
.. rst-class:: classref-method
|void| **add_point**\ (\ position\: :ref:`Vector3<class_Vector3>`, in\: :ref:`Vector3<class_Vector3>` = Vector3(0, 0, 0), out\: :ref:`Vector3<class_Vector3>` = Vector3(0, 0, 0), index\: :ref:`int<class_int>` = -1\ ) :ref:`🔗<class_Curve3D_method_add_point>`
Ajoute un point avec la ``position`` spécifiée relative à la propre position de la courbe, avec des points de contrôle d'entrée ``in`` et de sortie ``out``. Ajoute le nouveau point à la fin de la liste des points.
Si ``index`` est spécifié, le point est inséré juste avant le point existant à l'index identifié par ``index``. Chaque point existant commençant à l'index ``index`` est décalé d'un vers le fond vers la liste des points. L'index doit être supérieur ou égal à ``0`` et ne doit pas dépasser le nombre de points existants dans la ligne. Voir :ref:`point_count<class_Curve3D_property_point_count>`.
.. rst-class:: classref-item-separator
----
.. _class_Curve3D_method_clear_points:
.. rst-class:: classref-method
|void| **clear_points**\ (\ ) :ref:`🔗<class_Curve3D_method_clear_points>`
Supprime tous les points de la courbe.
.. rst-class:: classref-item-separator
----
.. _class_Curve3D_method_get_baked_length:
.. rst-class:: classref-method
:ref:`float<class_float>` **get_baked_length**\ (\ ) |const| :ref:`🔗<class_Curve3D_method_get_baked_length>`
Renvoie la longueur totale de la courbe, à partir de la distance entre les points mis en cache. Si la densité est suffisante (voir :ref:`bake_interval<class_Curve3D_property_bake_interval>`), cette longeur devrait être une approximation suffisante.
.. rst-class:: classref-item-separator
----
.. _class_Curve3D_method_get_baked_points:
.. rst-class:: classref-method
:ref:`PackedVector3Array<class_PackedVector3Array>` **get_baked_points**\ (\ ) |const| :ref:`🔗<class_Curve3D_method_get_baked_points>`
Renvoie le cache des points en tant que :ref:`PackedVector3Array<class_PackedVector3Array>`.
.. rst-class:: classref-item-separator
----
.. _class_Curve3D_method_get_baked_tilts:
.. rst-class:: classref-method
:ref:`PackedFloat32Array<class_PackedFloat32Array>` **get_baked_tilts**\ (\ ) |const| :ref:`🔗<class_Curve3D_method_get_baked_tilts>`
Renvoie le cache des inclinaisons en tant que :ref:`PackedFloat32Array<class_PackedFloat32Array>`.
.. rst-class:: classref-item-separator
----
.. _class_Curve3D_method_get_baked_up_vectors:
.. rst-class:: classref-method
:ref:`PackedVector3Array<class_PackedVector3Array>` **get_baked_up_vectors**\ (\ ) |const| :ref:`🔗<class_Curve3D_method_get_baked_up_vectors>`
Renvoie le cache des vecteurs haut dans un :ref:`PackedVector3Array<class_PackedVector3Array>`.
Si :ref:`up_vector_enabled<class_Curve3D_property_up_vector_enabled>` vaut ``false``, le cache sera vide.
.. rst-class:: classref-item-separator
----
.. _class_Curve3D_method_get_closest_offset:
.. rst-class:: classref-method
:ref:`float<class_float>` **get_closest_offset**\ (\ to_point\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Curve3D_method_get_closest_offset>`
Renvoie le décalage le plus proche de ``to_point``. Ce décalage est destiné à être utilisé dans :ref:`sample_baked()<class_Curve3D_method_sample_baked>` ou :ref:`sample_baked_up_vector()<class_Curve3D_method_sample_baked_up_vector>`.
\ ``to_point`` doit être dans l'espace local de cette courbe.
.. rst-class:: classref-item-separator
----
.. _class_Curve3D_method_get_closest_point:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **get_closest_point**\ (\ to_point\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Curve3D_method_get_closest_point>`
Renvoie le point en cache le plus proche (dans l'espace local de la courbe) de ``to_point``.
\ ``to_point`` doit être dans l'espace local de la courbe.
.. rst-class:: classref-item-separator
----
.. _class_Curve3D_method_get_point_in:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **get_point_in**\ (\ idx\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_Curve3D_method_get_point_in>`
Renvoie la position du point de contrôle menant au sommet d'index ``idx``. La position renvoyée est relative au sommet d'index ``idx``. Si l'index est hors limites, la fonction affiche une erreur dans la console, et renvoie ``(0, 0, 0)``.
.. rst-class:: classref-item-separator
----
.. _class_Curve3D_method_get_point_out:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **get_point_out**\ (\ idx\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_Curve3D_method_get_point_out>`
Renvoie la position du point de contrôle partant du sommet d'index ``idx``. La position renvoyée est relative au sommet d'index ``idx``. Si l'index est hors limites, la fonction affiche une erreur dans la console, et renvoie ``(0, 0, 0)``.
.. rst-class:: classref-item-separator
----
.. _class_Curve3D_method_get_point_position:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **get_point_position**\ (\ idx\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_Curve3D_method_get_point_position>`
Renvoie la position du sommet d'index ``idx``. Si l'index est hors des limites, la fonction affiche une erreur dans la console, et renvoie ``(0, 0, 0)``.
.. rst-class:: classref-item-separator
----
.. _class_Curve3D_method_get_point_tilt:
.. rst-class:: classref-method
:ref:`float<class_float>` **get_point_tilt**\ (\ idx\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_Curve3D_method_get_point_tilt>`
Renvoie l'angle d'inclinaison en radians pour le point à l'index ``idx``. Si l'index est hors des limites, la fonction affiche une erreur dans la console, et renvoie ``0``.
.. rst-class:: classref-item-separator
----
.. _class_Curve3D_method_remove_point:
.. rst-class:: classref-method
|void| **remove_point**\ (\ idx\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Curve3D_method_remove_point>`
Supprime le point d'index ``idx`` de la courbe. Affiche une erreur dans la console si ``idx`` est hors limites.
.. rst-class:: classref-item-separator
----
.. _class_Curve3D_method_sample:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **sample**\ (\ idx\: :ref:`int<class_int>`, t\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Curve3D_method_sample>`
Renvoie la position entre le sommet d'index ``idx`` et le sommet d'index ``idx + 1``, où ``t`` contrôle si le point est le premier sommet (``t = 0,0``), le dernier sommet (``t = 1.0``), ou entre ces deux valeurs. Les valeurs de ``t`` en dehors de l'intervalle (``0.0 >= t <=1``) donnent des résultats inattendus, mais prévisibles.
Si ``idx`` est hors limites, il est tronqué au premier ou au dernier sommet, et ``t`` est ignoré. Si la courbe n'a pas de points, la fonction affiche une erreur dans la console, et renvoie ``(0, 0, 0)``.
.. rst-class:: classref-item-separator
----
.. _class_Curve3D_method_sample_baked:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **sample_baked**\ (\ offset\: :ref:`float<class_float>` = 0.0, cubic\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_Curve3D_method_sample_baked>`
Renvoie un point dans la courbe à la position ``offset``, où ``offset`` est mesuré en unités 3D le long de la courbe. Pour cela, elle trouve les deux points dans le cache où le ``offset`` se situe entre, puis interpole les valeurs. Cette interpolation est cubique si ``cubic`` vaut ``true``, ou linéaire s'il vaut ``false``.
L'interpolation cubique tend à mieux suivre les courbes, mais l'interpolation linéaire est plus rapide (et souvent bien assez précise).
.. rst-class:: classref-item-separator
----
.. _class_Curve3D_method_sample_baked_up_vector:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **sample_baked_up_vector**\ (\ offset\: :ref:`float<class_float>`, apply_tilt\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_Curve3D_method_sample_baked_up_vector>`
Renvoie un vecteur haut dans la courbe à la position ``offset``, où ``offset`` est mesuré en unités 3D le long de la courbe. Pour cela, il trouve les deux vecteurs haut dans le cache où le ``offset`` se situe entre, puis interpole les valeurs. Si ``apply_tilt`` vaut ``true``, une inclinaison interpolée est aussi appliquée au vecteur haut interpolé.
Si la courbe n'a pas de vecteurs, la fonction affiche une erreur dans la console, et renvoie ``(0, 1, 0)``.
.. rst-class:: classref-item-separator
----
.. _class_Curve3D_method_sample_baked_with_rotation:
.. rst-class:: classref-method
:ref:`Transform3D<class_Transform3D>` **sample_baked_with_rotation**\ (\ offset\: :ref:`float<class_float>` = 0.0, cubic\: :ref:`bool<class_bool>` = false, apply_tilt\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_Curve3D_method_sample_baked_with_rotation>`
Renvoie une :ref:`Transform3D<class_Transform3D>` avec ``origin`` comme position du point, ``basis.x`` comme vecteur de côté, ``basis.y`` comme vecteur haut, ``basis.z`` comme vecteur avant. Lorsque la longueur de la courbe est de 0, il n'y a aucun moyen raisonnable de calculer la rotation, tous les vecteurs étant alignés sur les axes spatiaux globaux. Voir aussi :ref:`sample_baked()<class_Curve3D_method_sample_baked>`.
.. rst-class:: classref-item-separator
----
.. _class_Curve3D_method_samplef:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **samplef**\ (\ fofs\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Curve3D_method_samplef>`
Renvoie la position au sommet ``fofs``. Cela appelle :ref:`sample()<class_Curve3D_method_sample>` en utilisant la partie entière de ``fofs`` pour ``idx``, et sa partie décimale pour ``t``.
.. rst-class:: classref-item-separator
----
.. _class_Curve3D_method_set_point_in:
.. rst-class:: classref-method
|void| **set_point_in**\ (\ idx\: :ref:`int<class_int>`, position\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_Curve3D_method_set_point_in>`
Définit la position du point de contrôle menant au sommet d'index ``idx``. Si l'index est hors des limites, la fonction affiche une erreur dans la console. La position est relative au sommet.
.. rst-class:: classref-item-separator
----
.. _class_Curve3D_method_set_point_out:
.. rst-class:: classref-method
|void| **set_point_out**\ (\ idx\: :ref:`int<class_int>`, position\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_Curve3D_method_set_point_out>`
Définit la position du point de contrôle partant du sommet d'index ``idx``. Si l'index est hors des limites, la fonction affiche une erreur dans la console. La position est relative au sommet.
.. rst-class:: classref-item-separator
----
.. _class_Curve3D_method_set_point_position:
.. rst-class:: classref-method
|void| **set_point_position**\ (\ idx\: :ref:`int<class_int>`, position\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_Curve3D_method_set_point_position>`
Définit la position pour le sommet d'index ``idx``. Si l'index est hors des limites, la fonction affiche une erreur dans la console.
.. rst-class:: classref-item-separator
----
.. _class_Curve3D_method_set_point_tilt:
.. rst-class:: classref-method
|void| **set_point_tilt**\ (\ idx\: :ref:`int<class_int>`, tilt\: :ref:`float<class_float>`\ ) :ref:`🔗<class_Curve3D_method_set_point_tilt>`
Définit l'angle d'inclinaison en radians pour le point d'index ``idx``. Si l'index est hors limites, la fonction affiche une erreur dans la console.
L'inclinaison contrôle la rotation le long de l'axe avant qu'un objet parcourant la courbe aurait. Dans le cas d'une courbe contrôlant un :ref:`PathFollow3D<class_PathFollow3D>`, cette inclinaison est un décalage sur l'inclinaison naturelle que calcule le :ref:`PathFollow3D<class_PathFollow3D>`.
.. rst-class:: classref-item-separator
----
.. _class_Curve3D_method_tessellate:
.. rst-class:: classref-method
:ref:`PackedVector3Array<class_PackedVector3Array>` **tessellate**\ (\ max_stages\: :ref:`int<class_int>` = 5, tolerance_degrees\: :ref:`float<class_float>` = 4\ ) |const| :ref:`🔗<class_Curve3D_method_tessellate>`
Renvoie une liste de points le long de la courbe, avec une densité de point contrôlée par sa courbure. C'est-à-dire que les virages de la courbe auront plus de points que les segments bien droits.
Cette approximation génère des segments droits entre chaque point, puis divise ces segments jusqu'à ce que la nouvelle forme soit assez proche.
L'argument ``max_stages`` contrôle le nombre de divisions qu'un segment de courbe peut avoir avant qu'il soit considéré comme assez proche. Chaque division découpe le segment en deux, de sorte que les 5 étapes par défaut peuvent atteindre 32 divisions par segment de la courbe. Soyez donc prudent si vous augmentez cette valeur !
L'argument ``tolerance_degrees`` contrôle de quel angle, en degrés, le point du milieu d'un segment peut s'éloigner de la vraie courbe avant que le segment ne soit divisé.
.. rst-class:: classref-item-separator
----
.. _class_Curve3D_method_tessellate_even_length:
.. rst-class:: classref-method
:ref:`PackedVector3Array<class_PackedVector3Array>` **tessellate_even_length**\ (\ max_stages\: :ref:`int<class_int>` = 5, tolerance_length\: :ref:`float<class_float>` = 0.2\ ) |const| :ref:`🔗<class_Curve3D_method_tessellate_even_length>`
Renvoie une liste de points le long de la courbe, avec une densité presque uniforme. ``max_stages`` contrôle le nombre de subdivisions qu'un segment de courbe peut avoir avant qu'il ne soit considéré comme assez approximé. Chaque subdivision divise le segment en deux, de sorte que les 5 étapes par défaut peuvent atteindre jusqu'à 32 subdivisions par segment de courbe. À accroître avec soin !
\ ``tolerance_length`` contrôle la distance maximale entre deux points voisins, avant que le segment ne soit subdivisé.
.. |virtual| replace:: :abbr:`virtual (Cette méthode doit typiquement être redéfinie par l'utilisateur pour avoir un effet.)`
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
.. |const| replace:: :abbr:`const (Cette méthode n'a pas d'effets de bord. Elle ne modifie aucune des variables membres de l'instance.)`
.. |vararg| replace:: :abbr:`vararg (Cette méthode accepte n'importe quel nombre d'arguments après ceux décris ici.)`
.. |constructor| replace:: :abbr:`constructor (Cette méthode est utilisée pour construire un type.)`
.. |static| replace:: :abbr:`static (Cette méthode n'a pas besoin d'instance pour être appelée, elle peut donc être directement appelée en utilisant le nom de la classe.)`
.. |operator| replace:: :abbr:`operator (Cette méthode décrit un opérateur valide à utiliser avec ce type en tant qu'opérande gauche.)`
.. |bitfield| replace:: :abbr:`BitField (Cette valeur est un nombre entier composé d'un masque de bits des options suivantes.)`
.. |void| replace:: :abbr:`void (Aucune valeur de retour.)`
Reference in New Issue View Git Blame Copy Permalink