Attention: Here be dragons

This is the latest (unstable) version of this documentation, which may document features not available in or compatible with released stable versions of Godot.

Checking the stable version of the documentation...

Node3D

Hérite de : Node < Object

Hérité par : AudioListener3D, AudioStreamPlayer3D, BoneAttachment3D, Camera3D, CollisionObject3D, CollisionPolygon3D, CollisionShape3D, GridMap, ImporterMeshInstance3D, Joint3D, LightmapProbe, Marker3D, NavigationLink3D, NavigationObstacle3D, NavigationRegion3D, OpenXRCompositionLayer, OpenXRHand, OpenXRRenderModel, OpenXRRenderModelManager, Path3D, PathFollow3D, RayCast3D, RemoteTransform3D, ShapeCast3D, Skeleton3D, SkeletonModifier3D, SpringArm3D, SpringBoneCollision3D, VehicleWheel3D, VisualInstance3D, XRFaceModifier3D, XRNode3D, XROrigin3D

Objet de base dans l'espace 3D, hérité par tous les nœuds 3D.

Description

Le nœud Node3D est la représentation de base d'un nœud dans l'espace 3D. Tous les autres nœuds 3D héritent de cette classe.

Les opérations affines (translation, rotation, échelle) sont calculées dans le système de coordonnées par rapport au parent, à moins que le top_level du Node3D vaille true. Dans ce système de coordonnées, les opérations affines correspondent à des opérations affines directes sur la transformation transform du Node3D. Le terme d'espace parent désigne ce système de coordonnées. Le système de coordonnées joint au Node3D lui-même est appelé système de coordonnées objet-local, ou espace local.

Note : Sauf indication contraire, toutes les méthodes qui ont besoin de paramètres d'angle doivent recevoir des angles en radians. Pour convertir des degrés en radians, utilisez @GlobalScope.deg_to_rad().

Note : Dans Godot 3 et avant, Node3D était nommé Spatial.

Tutoriels

Propriétés

Basis	basis
Basis	global_basis
Vector3	global_position
Vector3	global_rotation
Vector3	global_rotation_degrees
Transform3D	global_transform
Vector3	position	`Vector3(0, 0, 0)`
Quaternion	quaternion
Vector3	rotation	`Vector3(0, 0, 0)`
Vector3	rotation_degrees
RotationEditMode	rotation_edit_mode	`0`
EulerOrder	rotation_order	`2`
Vector3	scale	`Vector3(1, 1, 1)`
bool	top_level	`false`
Transform3D	transform	`Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0)`
NodePath	visibility_parent	`NodePath("")`
bool	visible	`true`

Méthodes

void	add_gizmo(gizmo: Node3DGizmo)
void	clear_gizmos()
void	clear_subgizmo_selection()
void	force_update_transform()
Array[Node3DGizmo]	get_gizmos() const
Transform3D	get_global_transform_interpolated()
Node3D	get_parent_node_3d() const
World3D	get_world_3d() const
void	global_rotate(axis: Vector3, angle: float)
void	global_scale(scale: Vector3)
void	global_translate(offset: Vector3)
void	hide()
bool	is_local_transform_notification_enabled() const
bool	is_scale_disabled() const
bool	is_transform_notification_enabled() const
bool	is_visible_in_tree() const
void	look_at(target: Vector3, up: Vector3 = Vector3(0, 1, 0), use_model_front: bool = false)
void	look_at_from_position(position: Vector3, target: Vector3, up: Vector3 = Vector3(0, 1, 0), use_model_front: bool = false)
void	orthonormalize()
void	rotate(axis: Vector3, angle: float)
void	rotate_object_local(axis: Vector3, angle: float)
void	rotate_x(angle: float)
void	rotate_y(angle: float)
void	rotate_z(angle: float)
void	scale_object_local(scale: Vector3)
void	set_disable_scale(disable: bool)
void	set_identity()
void	set_ignore_transform_notification(enabled: bool)
void	set_notify_local_transform(enable: bool)
void	set_notify_transform(enable: bool)
void	set_subgizmo_selection(gizmo: Node3DGizmo, id: int, transform: Transform3D)
void	show()
Vector3	to_global(local_point: Vector3) const
Vector3	to_local(global_point: Vector3) const
void	translate(offset: Vector3)
void	translate_object_local(offset: Vector3)
void	update_gizmos()

Signaux

visibility_changed() 🔗

Émis lorsque la visibilité de ce nœud change (voir visible et is_visible_in_tree()).

Ce signal est émis après la notification NOTIFICATION_VISIBILITY_CHANGED correspondante.

Énumérations

enum RotationEditMode: 🔗

RotationEditMode ROTATION_EDIT_MODE_EULER = 0

The rotation is edited using a Vector3 in Euler angles. In Godot, Euler angles always use intrinsic order, meaning that rotation happens around the local axes of the object.

RotationEditMode ROTATION_EDIT_MODE_QUATERNION = 1

The rotation is edited using a Quaternion. Quaternions avoid gimbal lock and having to choose an order of rotation, but are less intuitive. Quaternion rotation is mostly the same as rotors in 3D geometric algebra, except that the numbers are labeled differently.

RotationEditMode ROTATION_EDIT_MODE_BASIS = 2

La rotation est modifiée en utilisant une Basis. Dans ce mode, les axes bruts de basis peuvent être librement modifiés, mais la propriété scale n'est pas disponible.

Constantes

NOTIFICATION_TRANSFORM_CHANGED = 2000 🔗

Notification reçue lorsque la global_transform de ce nœud change, si is_transform_notification_enabled() vaut true. Voir aussi set_notify_transform().

Note : La plupart des nœuds 3D tels que VisualInstance3D ou CollisionObject3D activent ceci automatiquement pour fonctionner correctement.

Note : Dans l'éditeur, les nœuds propagent cette notification à leurs enfants si un manipulateur est attaché (voir add_gizmo()).

NOTIFICATION_ENTER_WORLD = 41 🔗

Notification reçue lorsque ce nœud est enregistré avec un nouveau World3D (voir get_world_3d()).

NOTIFICATION_EXIT_WORLD = 42 🔗

Notification received when this node is unregistered from the current World3D (see get_world_3d()).

This notification is sent in reversed order.

NOTIFICATION_VISIBILITY_CHANGED = 43 🔗

Notification reçue lorsque la visibilité de ce nœud change (voir visible et is_visible_in_tree()).

Cette notification est reçue avant le signal visibility_changed correspondant.

NOTIFICATION_LOCAL_TRANSFORM_CHANGED = 44 🔗

Notification reçue lorsque la transform de ce nœud change, si is_local_transform_notification_enabled() vaut true. Ceci n'est pas reçu lorsque la transform d'un Node3D parent change. Voir aussi set_notify_local_transform().

Note : Quelques nœuds 3D tels que CSGShape3D ou CollisionObject3D activent ceci automatiquement pour fonctionner correctement.

Descriptions des propriétés

Basis basis 🔗

void set_basis(value: Basis)
Basis get_basis()

Base de la propriété transform. Représente la rotation, l'échelle et le cisaillement de ce nœud dans l'espace parent (relatif au nœud parent).

Basis global_basis 🔗

void set_global_basis(value: Basis)
Basis get_global_basis()

Base de la propriété global_transform. Représente la rotation, l'échelle et le cisaillement de ce nœud dans l'espace global (relatif au monde).

Note : Si le nœud n'est pas à l'intérieur de l’arborescence, obtenir cette propriété échoue et renvoie Basis.IDENTITY.

Vector3 global_position 🔗

void set_global_position(value: Vector3)
Vector3 get_global_position()

Position globale (translation) de ce nœud dans l'espace global (relatif au monde). Ceci est équivalent à l'origine Transform3D.origin de global_transform.

Note : Si le nœud n'est pas à l'intérieur de l’arborescence, obtenir cette propriété échoue et renvoie Vector3.ZERO.

Vector3 global_rotation 🔗

void set_global_rotation(value: Vector3)
Vector3 get_global_rotation()

La rotation globale de ce nœud en tant qu'angles d'Euler, en radians et dans l'espace global (relatif au monde). Cette valeur est obtenue à partir de la rotation de global_basis.

Le Vector3.x est l'angle autour de l'axe X global (roulis);
Le Vector3.y est l'angle autour de l'axe Y global (tangage);
Le Vector3.z est l'angle autour de l'axe Z global (lacet).

Note : Contrairement à rotation, cette propriété suit toujours la convention YXZ (@GlobalScope.EULER_ORDER_YXZ).

Note : Si le nœud n'est pas à l'intérieur de l’arborescence, obtenir cette propriété échoue et renvoie Vector3.ZERO.

Vector3 global_rotation_degrees 🔗

void set_global_rotation_degrees(value: Vector3)
Vector3 get_global_rotation_degrees()

La rotation globale global_rotation de ce nœud, en degrés au lieu de radians.

Note : Si le nœud n'est pas à l'intérieur de l’arborescence, obtenir cette propriété échoue et renvoie Vector3.ZERO.

Transform3D global_transform 🔗

void set_global_transform(value: Transform3D)
Transform3D get_global_transform()

La transformation de ce nœud, dans l'espace global (relatif au monde). Contient et représente la position globale global_position de ce nœud, la rotation globaleglobal_rotation et l'échelle globale.

Note : Si le nœud n'est pas à l'intérieur de l’arborescence, obtenir cette propriété échoue et renvoie Transform3D.IDENTITY.

Vector3 position = Vector3(0, 0, 0) 🔗

void set_position(value: Vector3)
Vector3 get_position()

Position (translation) de ce nœud dans l'espace parent (relatif au nœud parent). Il s'agit de l'équivalent de Transform3D.origin de transform.

Quaternion quaternion 🔗

void set_quaternion(value: Quaternion)
Quaternion get_quaternion()

Rotation de ce nœud représentée en tant que Quaternion dans l'espace parent (relatif au nœud parent). Cette valeur est obtenue à partir de la rotation de basis.

Note : Les quaternions sont beaucoup plus adaptés aux maths 3D mais sont moins intuitifs. Définir cette propriété peut être utile pour interpoler (voir Quaternion.slerp()).

Vector3 rotation = Vector3(0, 0, 0) 🔗

void set_rotation(value: Vector3)
Vector3 get_rotation()

Rotation of this node as Euler angles, in radians and in parent space (relative to the parent node). This value is obtained from basis's rotation.

The Vector3.x is the angle around the local X axis (pitch);
The Vector3.y is the angle around the local Y axis (yaw);
The Vector3.z is the angle around the local Z axis (roll).

The order of each consecutive rotation can be changed with rotation_order (see EulerOrder constants). In Godot, Euler angles always use intrinsic order. By default, the intrinsic YXZ convention is used (@GlobalScope.EULER_ORDER_YXZ).

Note: This property is edited in degrees in the inspector. If you want to use degrees in a script, use rotation_degrees.

Vector3 rotation_degrees 🔗

void set_rotation_degrees(value: Vector3)
Vector3 get_rotation_degrees()

La rotation de ce nœud, en degrés au lieu de radians.

Note : Il ne s'agit pas la propriété disponible dans le dock Inspecteur.

RotationEditMode rotation_edit_mode = 0 🔗

void set_rotation_edit_mode(value: RotationEditMode)
RotationEditMode get_rotation_edit_mode()

La façon dont la rotation et l'échelle de ce nœud sont affichées dans le dock Inspecteur.

EulerOrder rotation_order = 2 🔗

void set_rotation_order(value: EulerOrder)
EulerOrder get_rotation_order()

The axis rotation order of the rotation property. In Godot, Euler angles always use intrinsic order, meaning that the final orientation is calculated by rotating around the local axes in this order.

Vector3 scale = Vector3(1, 1, 1) 🔗

void set_scale(value: Vector3)
Vector3 get_scale()

Échelle de ce nœud dans l'espace local (relatif à ce nœud). Cette valeur est obtenue à partir de l'échelle de basis.

Note : Le comportement de certains types de nœud 3D n'est pas affecté par cette propriété. Ceux-ci comprennent Light3D, Camera3D, AudioStreamPlayer3D, et d'autres.

Attention : Les composantes de l'échelle doivent être toutes positives ou toutes négatives, et pas exactement 0.0. Sinon, il ne sera pas possible d'obtenir l'échelle de la basis. Cela peut entraîner la perte de l'échelle prévue lorsqu'elle est rechargée depuis le disque, et potentiellement d'autres comportements instables.

bool top_level = false 🔗

void set_as_top_level(value: bool)
bool is_set_as_top_level()

Si true, le nœud n'hérite pas ses transformations de son parent. Ainsi, les transformations du nœud ne seront que dans l'espace global, ce qui signifie également que global_transform et transform seront identiques.

Transform3D transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0) 🔗

void set_transform(value: Transform3D)
Transform3D get_transform()

La transformation locale de ce nœud, dans l'espace parent (relatif au nœud parent). Contient et représente la position, rotation et scale de ce nœud.

NodePath visibility_parent = NodePath("") 🔗

void set_visibility_parent(value: NodePath)
NodePath get_visibility_parent()

Path to the visibility range parent for this node and its descendants. The visibility parent must be a GeometryInstance3D.

Any visual instance will only be visible if the visibility parent (and all of its visibility ancestors) is hidden by being closer to the camera than its own GeometryInstance3D.visibility_range_begin. Nodes hidden via the visible property are essentially removed from the visibility dependency tree, so dependent instances will not take the hidden node or its descendants into account.

bool visible = true 🔗

void set_visible(value: bool)
bool is_visible()

Si true, ce nœud peut être visible. Le nœud n'est rendu que si tous ses parents le sont également. Cela signifie que is_visible_in_tree() doit renvoyer true.

Descriptions des méthodes

void add_gizmo(gizmo: Node3DGizmo) 🔗

Attache le manipulateur gizmo donné à ce nœud. Fonctionne seulement dans l'éditeur.

Note : gizmo devrait être un EditorNode3DGizmo. Le type d'argument est Node3DGizmo pour éviter de dépendre sur des classes de l'éditeur dans Node3D.

void clear_gizmos() 🔗

Retire tous les objets EditorNode3DGizmo attachés à ce nœud. Fonctionne seulement dans l'éditeur.

void clear_subgizmo_selection() 🔗

Désélectionne tous les sous-manipulateurs pour ce nœuds. Utile à appeler lorsque le sous-manipulateur sélectionné peut ne plus exister après un changement de propriété. Fonctionne seulement dans l'éditeur.

void force_update_transform() 🔗

Force la transformation globale global_transform du nœud à se mettre à jour, en envoyant NOTIFICATION_TRANSFORM_CHANGED. Échoue si le nœud n'est pas à l'intérieur de l'arboresence.

Note : Pour des raisons de performance, les changements de transformation sont généralement accumulés et appliqués en une fois à la fin de la trame. La mise à jour se propage aussi vers les enfants Node3D. Par conséquent, utilisez cette méthode seulement lorsque vous avez besoin d'une transformation à jour (comme pendant les opérations de physique).

Array[Node3DGizmo] get_gizmos() const 🔗

Renvoie tous les objets EditorNode3DGizmo attachés à ce nœud. Fonctionne seulement dans l'éditeur.

Transform3D get_global_transform_interpolated() 🔗

When using physics interpolation, there will be circumstances in which you want to know the interpolated (displayed) transform of a node rather than the standard transform (which may only be accurate to the most recent physics tick).

This is particularly important for frame-based operations that take place in Node._process(), rather than Node._physics_process(). Examples include Camera3Ds focusing on a node, or finding where to fire lasers from on a frame rather than physics tick.

Note: This function creates an interpolation pump on the Node3D the first time it is called, which can respond to physics interpolation resets. If you get problems with "streaking" when initially following a Node3D, be sure to call get_global_transform_interpolated() at least once before resetting the Node3D physics interpolation.

Node3D get_parent_node_3d() const 🔗

Renvoie le Node3D parent qui affecte directement la global_transform de ce nœud. Renvoie null si aucun parent n'existe, le parent n'est pas un Node3D, ou top_level vaut true.

Note : Cette méthode n'est pas toujours équivalente à Node.get_parent(), qui ne prend pas en compte top_level.

World3D get_world_3d() const 🔗

Renvoie le World3D avec lequel ce nœud est enregistré.

Habituellement, il est identique au monde utilisé par le viewport de ce nœud (voir Node.get_viewport() et Viewport.find_world_3d()).

void global_rotate(axis: Vector3, angle: float) 🔗

Tourne la global_basis de ce nœud autour de l'axe global axis avec un angle donné, en radians. Cette opération est calculée dans l'espace global (relatif au monde) et préserve la position globale global_position.

void global_scale(scale: Vector3) 🔗

Redimensionne la base globale global_basis de ce nœud par le facteur scale donné. Cette opération est calculée dans l'espace global (relatif au monde) et préserve la global_position.

Note : Cette méthode ne doit pas être confondue avec la propriété scale.

void global_translate(offset: Vector3) 🔗

Ajoute la translation offset donnée à la position globale global_position du nœud, dans l'espace global (relatif au monde).

void hide() 🔗

Empêche ce nœud d'être rendu. Équivalent à définir visible à false. Il s'agit du contraire de show().

bool is_local_transform_notification_enabled() const 🔗

Renvoie true si le nœud reçoit NOTIFICATION_LOCAL_TRANSFORM_CHANGED chaque fois que transform change. Ceci est activé avec set_notify_local_transform().

bool is_scale_disabled() const 🔗

Renvoie true si le global_transform du nœud est automatiquement orthonormalisée. Cela résulte en ce nœud n'apparaissant pas comme déformé, comme si son échelle globale était définie à Vector3.ONE (ou son homologue négatif). Voir aussi set_disable_scale() et orthonormalize().

Note : transform n'est pas affectée par ce paramètre.

bool is_transform_notification_enabled() const 🔗

Renvoie true si le nœud reçoit NOTIFICATION_TRANSFORM_CHANGED chaque fois que global_transform change. Ceci est activé avec set_notify_transform().

bool is_visible_in_tree() const 🔗

Returns true if this node is inside the scene tree and the visible property is true for this node and all of its Node3D ancestors in sequence. An ancestor of any other type (such as Node or Node2D) breaks the sequence. See also Node.get_parent().

Note: This method cannot take VisualInstance3D.layers into account, so even if this method returns true, the node may not be rendered.

void look_at(target: Vector3, up: Vector3 = Vector3(0, 1, 0), use_model_front: bool = false) 🔗

Tourne le nœud de sorte à ce que l'axe avant local (-Z, Vector3.FORWARD) pointe vers la position cible target. Cette opération est calculée dans l'espace global (relatif au monde).

L'axe local haut (+Y) pointe aussi près du vecteur up que possible tout en restant perpendiculaire à l'axe avant local. La transformation résultante est orthogonale, et l'échelle est préservée. Une échelle non uniforme peut ne pas fonctionner correctement.

La position cible target ne peut être la même que la position du nœud, le vecteur up ne peut être Vector3.ZERO. De plus, la direction de la position du nœud vers target ne peut pas être parallèle au vecteur up, pour éviter une rotation intempestive autour de l'axe Z local.

Si use_model_front vaut true, l'axe +Z (avant des ressources) est traité comme l'avant (implique que +X est la gauche) et pointe vers target. Par défaut, l'axe -Z (avant de la caméra) est traité comme l'avant (implique que +X est la droite).

Note : Cette méthode échoue si le nœud n'est pas dans l'arborescence de scène. Si nécessaire, utilisez plutôt look_at_from_position().

void look_at_from_position(position: Vector3, target: Vector3, up: Vector3 = Vector3(0, 1, 0), use_model_front: bool = false) 🔗

Déplace le nœud vers la position spécifiée, puis pivote vers le nœud pour pointer vers la position de la cible target, comme avec look_at(). Cette opération est calculée dans l'espace global (relatif au monde).

void orthonormalize() 🔗

Orthonormalise la base de ce nœud. Cette méthode définit l'échelle scale de ce nœud à Vector3.ONE (ou son homologue négatif), mais conserve la position et rotation. Voir aussi Transform3D.orthonormalized().

void rotate(axis: Vector3, angle: float) 🔗

Tourne la basis de ce nœud autour de l'axe axis avec un angle donné, en radians. Cette opération est calculée dans l'espace parent (relatif au parent) et préserve la position.

void rotate_object_local(axis: Vector3, angle: float) 🔗

Tourne la basis de ce nœud autour de l'axe axis avec un angle donné, en radians. Cette opération est calculée dans l'espace local (relatif à ce nœud) et préserve la position.

void rotate_x(angle: float) 🔗

Tourne la basis de ce nœud autour de l'axe X avec un angle donné, en radians. Cette opération est calculée dans l'espace parent (relatif au parent) et préserve la position.

void rotate_y(angle: float) 🔗

Tourne la basis de ce nœud autour de l'axe Y avec un angle donné, en radians. Cette opération est calculée dans l'espace parent (relatif au parent) et préserve la position.

void rotate_z(angle: float) 🔗

Tourne la basis de ce nœud autour de l'axe Z avec un angle donné, en radians. Cette opération est calculée dans l'espace parent (relatif au parent) et préserve la position.

void scale_object_local(scale: Vector3) 🔗

Redimensionne la base basis de ce nœud par le facteur scale donné. Cette opération est calculée dans l'espace local (relatif à ce nœud) et préserve la position.

void set_disable_scale(disable: bool) 🔗

Si true, la transformation globale global_transform du nœud est automatiquement orthonormalisée. Cela résulte en ce nœud n'apparaissant pas comme déformé, comme si son échelle globale était définie à Vector3.ONE (ou son homologue négatif). Voir aussi is_scale_disabled() et orthonormalize().

Note : transform n'est pas affecté par ce paramètre.

void set_identity() 🔗

Définit la transformation transform de ce nœud à Transform3D.IDENTITY, ce qui réinitialise toutes les transformations dans l'espace parent (position, rotation et scale).

void set_ignore_transform_notification(enabled: bool) 🔗

Si true, le nœud ne recevra pas NOTIFICATION_TRANSFORM_CHANGED ou NOTIFICATION_LOCAL_TRANSFORM_CHANGED.

Il peut être utile d'appeler cette méthode lors de la manipulation de ces notifications pour éviter une récursion infinie.

void set_notify_local_transform(enable: bool) 🔗

Si true, le nœud recevra NOTIFICATION_LOCAL_TRANSFORM_CHANGED chaque fois que transform change.

Note : Certains nœuds 3D tels que CSGShape3D ou CollisionShape3D activement automatiquement ceci pour fonctionner correctement.

void set_notify_transform(enable: bool) 🔗

Si true, le nœud recevra NOTIFICATION_TRANSFORM_CHANGED à chaque fois que global_transform change.

Note : La plupart des nœuds 3D tels que VisualInstance3D ou CollisionObject3D activeront automatiquement ceci pour fonctionner correctement.

Note : Dans l'éditeur, les nœuds propagent cette notification à leurs enfants si un manipulateur est attaché (voir add_gizmo()).

void set_subgizmo_selection(gizmo: Node3DGizmo, id: int, transform: Transform3D) 🔗

Sélectionne le sous-manipulateur gizmo avec l'id donné et définit sa transformation. Fonctionne seulement dans l'éditeur.

Note : L'objet manipulateur serait généralement une instance d'EditorNode3DGizmo, mais le type d'argument est gardé générique pour éviter de créer une dépendance aux classes d'éditeur dans Node3D.

void show() 🔗

Autorise à ce nœud d'être rendu. Équivalent à définir visible à true. Il s'agit du contraire de hide().

Vector3 to_global(local_point: Vector3) const 🔗

Renvoie le point local local_point converti de l'espace local de ce nœud vers l'espace global. Il s'agit du contraire de to_local().

Vector3 to_local(global_point: Vector3) const 🔗

Renvoie le point global global_point converti de l'espace global vers l'espace local de ce nœud. Il s'agit du contraire de to_global().

void translate(offset: Vector3) 🔗

Ajoute la translation offset donnée à la position du nœud, dans l'espace local (relatif à ce nœud).

Note : Préférez utiliser translate_object_local(), car cette méthode peut être changée dans une version future.

Note : Malgré la convention de dénomination, cette opération n'est pas calculée dans l'espace parent pour des raisons de compatibilité. Pour translater dans l'espace parent, ajoutez offset à la position (node_3d.position += offset).

void translate_object_local(offset: Vector3) 🔗

Ajoute la translation offset donnée à la position du nœud, dans l'espace local (relatif à ce nœud).

void update_gizmos() 🔗

Met à jour tous les objets EditorNode3DGizmo attachés à ce nœud. Fonctionne seulement dans l'éditeur.