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

Parallax2D

Hérite de : Node2D < CanvasItem < Node < Object

Un nœud utilisé pour créer un arrière-plan à défilement parallaxe.

Description

Un Parallax2D est utilisé pour créer un effet de parallaxe. Il peut se déplacer à une vitesse différente par rapport au mouvement de la caméra en utilisant scroll_scale. Cela crée une illusion de profondeur dans un jeu 2D. Si du défilement manuel est souhaité, la position de la Camera2D peut être ignorée avec ignore_camera_scroll.

Note : Tout changement à la position de ce nœud effectué après son entrée dans l'arbre de scène sera redéfini si ignore_camera_scroll vaut false ou que screen_offset est modifié.

Tutoriels

Parallaxe 2D

Propriétés

Vector2	autoscroll	`Vector2(0, 0)`
bool	follow_viewport	`true`
bool	ignore_camera_scroll	`false`
Vector2	limit_begin	`Vector2(-10000000, -10000000)`
Vector2	limit_end	`Vector2(10000000, 10000000)`
PhysicsInterpolationMode	physics_interpolation_mode	`2` (overrides Node)
Vector2	repeat_size	`Vector2(0, 0)`
int	repeat_times	`1`
Vector2	screen_offset	`Vector2(0, 0)`
Vector2	scroll_offset	`Vector2(0, 0)`
Vector2	scroll_scale	`Vector2(1, 1)`

Descriptions des propriétés

Vector2 autoscroll = Vector2(0, 0) 🔗

void set_autoscroll(value: Vector2)
Vector2 get_autoscroll()

Vélocité à laquelle le décalage défile automatiquement, en pixels par seconde.

bool follow_viewport = true 🔗

void set_follow_viewport(value: bool)
bool get_follow_viewport()

Si true, ce Parallax2D est décalé par la position actuelle de la caméra. Si le Parallax2D se trouve dans un CanvasLayer séparé de la caméra actuelle, il peut être souhaité de faire correspondre la valeur avec CanvasLayer.follow_viewport_enabled.

bool ignore_camera_scroll = false 🔗

void set_ignore_camera_scroll(value: bool)
bool is_ignore_camera_scroll()

Si true, la position de Parallax2D n'est pas affectée par la position de la caméra.

Vector2 limit_begin = Vector2(-10000000, -10000000) 🔗

void set_limit_begin(value: Vector2)
Vector2 get_limit_begin()

Limites en haut à gauche pour que le défilement commence. Si la caméra est en dehors de cette limite, le Parallax2D cesse de défiler. Doit être inférieur à limit_end moins la taille du viewport pour fonctionner.

Vector2 limit_end = Vector2(10000000, 10000000) 🔗

void set_limit_end(value: Vector2)
Vector2 get_limit_end()

Limites en bas à droite pour que le défilement s'arrête. Si la caméra est en dehors de cette limite, le Parallax2D cesse de défiler. Doit être supérieur à limit_begin plus la taille du viewport pour fonctionner.

Vector2 repeat_size = Vector2(0, 0) 🔗

void set_repeat_size(value: Vector2)
Vector2 get_repeat_size()

Répète la Texture2D de chacun des enfants de ce nœud et les décale de cette valeur. Lors du défilement, la position du nœud boucle, donnant l'illusion d'un arrière-plan défilant de manière infinie si les valeurs sont plus grandes que la taille de l'écran. Si un axe est défini à 0, la Texture2D ne sera pas répétée.

int repeat_times = 1 🔗

void set_repeat_times(value: int)
int get_repeat_times()

Redéfinit le nombre de fois que la texture répète. Chaque copie de la texture s'écarte uniformément de l'original de repeat_size. Utile pour dézoomer avec une caméra.

Vector2 screen_offset = Vector2(0, 0) 🔗

void set_screen_offset(value: Vector2)
Vector2 get_screen_offset()

Décalage utilisé pour défiler ce Parallax2D. Cette valeur est mise à jour automatiquement sauf si ignore_camera_scroll vaut true.

Vector2 scroll_offset = Vector2(0, 0) 🔗

void set_scroll_offset(value: Vector2)
Vector2 get_scroll_offset()

Le décalage du Parallax2D. Similaire à screen_offset et Node2D.position, mais ne sera pas redéfini.

Note : Les valeurs vont boucler si repeat_size est défini supérieur à 0.

Vector2 scroll_scale = Vector2(1, 1) 🔗

void set_scroll_scale(value: Vector2)
Vector2 get_scroll_scale()

Multiplicateur du décalage final du Parallax2D. Peut être utilisé pour simuler de la distance à la caméra.

Par exemple, une valeur de 1 défile à la même vitesse que la caméra. Une valeur supérieure à 1 défile plus vite, faisant apparaître les objets comme plus proches. Une valeur inférieure à 1 défile plus lentement, faisant apparaître les objets comme plus lointains, et une valeur de 0 arrête complètement les objets.