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...

Node2D

Hérite de : CanvasItem < Node < Object

Hérité par : AnimatedSprite2D, AudioListener2D, AudioStreamPlayer2D, BackBufferCopy, Bone2D, Camera2D, CanvasGroup, CanvasModulate, CollisionObject2D, CollisionPolygon2D, CollisionShape2D, CPUParticles2D, GPUParticles2D, Joint2D, Light2D, LightOccluder2D, Line2D, Marker2D, MeshInstance2D, MultiMeshInstance2D, NavigationLink2D, NavigationObstacle2D, NavigationRegion2D, Parallax2D, ParallaxLayer, Path2D, PathFollow2D, Polygon2D, RayCast2D, RemoteTransform2D, ShapeCast2D, Skeleton2D, Sprite2D, TileMap, TileMapLayer, TouchScreenButton, VisibleOnScreenNotifier2D

Un objet de jeu 2D, hérité par tous les nœuds relatifs à la 2D. A une position, une rotation, une échelle et un cisaillement.

Description

Un objet de jeu 2D, avec une transformation (position, rotation et échelle). Tous les nœuds 2D, y compris les objets physiques et les sprites, héritent de Node2D. Utilisez Node2D comme nœud parent pour déplacer, mettre à l'échelle et pivoter des enfants dans un projet 2D. Donne également le contrôle sur l'ordre de rendu des nœuds.

Note : Comme Node2D et Control héritent de CanvasItem, ils partagent plusieurs concepts de la classe tels que les propriétés CanvasItem.z_index et CanvasItem.visible.

Tutoriels

Propriétés

Vector2	global_position
float	global_rotation
float	global_rotation_degrees
Vector2	global_scale
float	global_skew
Transform2D	global_transform
Vector2	position	`Vector2(0, 0)`
float	rotation	`0.0`
float	rotation_degrees
Vector2	scale	`Vector2(1, 1)`
float	skew	`0.0`
Transform2D	transform

Méthodes

void	apply_scale(ratio: Vector2)
float	get_angle_to(point: Vector2) const
Transform2D	get_relative_transform_to_parent(parent: Node) const
void	global_translate(offset: Vector2)
void	look_at(point: Vector2)
void	move_local_x(delta: float, scaled: bool = false)
void	move_local_y(delta: float, scaled: bool = false)
void	rotate(radians: float)
Vector2	to_global(local_point: Vector2) const
Vector2	to_local(global_point: Vector2) const
void	translate(offset: Vector2)

Descriptions des propriétés

Vector2 global_position 🔗

void set_global_position(value: Vector2)
Vector2 get_global_position()

Position globale. Voir aussi position.

float global_rotation 🔗

void set_global_rotation(value: float)
float get_global_rotation()

Rotation globale en radians. Voir aussi rotation.

float global_rotation_degrees 🔗

void set_global_rotation_degrees(value: float)
float get_global_rotation_degrees()

Propriété d'aide pour accéder à global_rotation en degrés au lieu de radians. Voir aussi rotation_degrees.

Vector2 global_scale 🔗

void set_global_scale(value: Vector2)
Vector2 get_global_scale()

Échelle globale. Voir aussi scale.

float global_skew 🔗

void set_global_skew(value: float)
float get_global_skew()

Cisaillement global en radians. Voir aussi skew.

Transform2D global_transform 🔗

void set_global_transform(value: Transform2D)
Transform2D get_global_transform()

Transform2D globale. Voir aussi transform.

Vector2 position = Vector2(0, 0) 🔗

void set_position(value: Vector2)
Vector2 get_position()

La position, relative au parent du nœud. Voir aussi global_position.

float rotation = 0.0 🔗

void set_rotation(value: float)
float get_rotation()

Rotation en radians, par rapport au parent du nœud. Voir aussi global_rotation.

Note : Cette propriété est modifiée en degrés dans l'inspecteur. Si vous voulez utiliser des degrés dans un script, utilisez rotation_degrees.

float rotation_degrees 🔗

void set_rotation_degrees(value: float)
float get_rotation_degrees()

Propriété d'aide pour accéder à rotation en degrés au lieu de radians. Voir aussi global_rotation_degrees.

Vector2 scale = Vector2(1, 1) 🔗

void set_scale(value: Vector2)
Vector2 get_scale()

L'échelle du nœud, relative au parent du nœud. Valeur sans échelle : (1, 1). Voir aussi global_scale.

Note : Les échelles X négatives en 2D ne sont pas décomposables de la matrice de transformation. En raison de la façon dont l'échelle est représentée avec des matrices de transformation dans Godot, les échelles négatives sur l'axe X seront changées en échelles négatives sur l'axe Y et une rotation de 180 degrés lors de la décomposition.

float skew = 0.0 🔗

void set_skew(value: float)
float get_skew()

S'il s'agit d'une valeur non nulle, incline le nœud dans une direction ou une autre. Cela peut être utilisé pour des effets de pseudo-3D. Voir aussi global_skew.

Note : Le cisaillement est effectué sur l'axe X seulement, et entre la rotation et la mise à l'échelle.

Note : Cette propriété est modifiée en degrés par l'inspecteur. Si vous voulez utiliser des degrés dans un script, utilisez skew = deg_to_rad(value_in_degrees).

Transform2D transform 🔗

void set_transform(value: Transform2D)
Transform2D get_transform()

La Transform2D du nœud, par rapport au parent du nœud. Voir aussi global_transform.

Descriptions des méthodes

void apply_scale(ratio: Vector2) 🔗

Multiplie l'échelle actuelle par le vecteur ratio.

float get_angle_to(point: Vector2) const 🔗

Returns the angle between the node and the point in radians. See also look_at().

Illustration of the returned angle.

Transform2D get_relative_transform_to_parent(parent: Node) const 🔗

Renvoie la Transform2D relative au parent de ce nœud.

void global_translate(offset: Vector2) 🔗

Ajoute le vecteur de décalage offset à la position globale du nœud.

void look_at(point: Vector2) 🔗

Rotates the node so that its local +X axis points towards the point, which is expected to use global coordinates. This method is a combination of both rotate() and get_angle_to().

point should not be the same as the node's position, otherwise the node always looks to the right.

void move_local_x(delta: float, scaled: bool = false) 🔗

Applies a local translation on the node's X axis with the amount specified in delta. If scaled is false, normalizes the movement to occur independently of the node's scale.

void move_local_y(delta: float, scaled: bool = false) 🔗

Applies a local translation on the node's Y axis with the amount specified in delta. If scaled is false, normalizes the movement to occur independently of the node's scale.

void rotate(radians: float) 🔗

Applies a rotation to the node, in radians, starting from its current rotation. This is equivalent to rotation += radians.

Vector2 to_global(local_point: Vector2) const 🔗

Transforme la position locale fournie en position dans l'espace de coordonnées global. L'entrée devrait être locale par rapport au Node2D sur lequel elle est appelée. Par ex., l'application de cette méthode aux positions des nœuds enfants transformera correctement leurs positions dans l'espace de coordonnées global, mais l'appliquer sur la propre position du nœud donnera un résultat incorrect, car elle intégrera la propre transformation du nœud dans sa position globale.

Vector2 to_local(global_point: Vector2) const 🔗

Transforme la position globale fournie en position dans l'espace de coordonnées local. La sortie sera locale par rapport au Node2D sur lequel elle est appelée. Cela signifie qu'elle est appropriée pour déterminer la position des nœuds enfants, mais non appropriée pour déterminer la propre position du nœud par rapport à son parent.

void translate(offset: Vector2) 🔗

Translates the node by the given offset in local coordinates. This is equivalent to position += offset.