Utilisation de SceneTree¶

Introduction¶

Dans le tutoriel précédent, tout tournait autour du concept des nœuds. Chaque scène est simplement une collection de nœud. Elles deviennent actives une fois entrée dans l'arbre de scène.

MainLoop¶

La façon dont Godot fonctionne en interne est la suivante : Au départ, la seule instance qui fonctionne est la classe OS, ensuite, tous les pilotes, serveurs, langages de script, système de gestion de scènes ... sont chargés.

Quand l'initialisation est terminée, OS doit être fournie à MainLoop pour fonctionner. Jusqu'à ce point, tout ceci est du fonctionnement interne (vous pouvez consulter le fichier main/main.cpp dans le code source si jamais vous êtes intéressé de voir comment cela fonctionne en interne).

Le programme utilisateur, ou le jeu, démarre dans le MainLoop. Cette classe a quelques méthodes, pour l'initialisation, l'inactivité (rappel synchronisé par trame), fixé (rappel synchronisé par la physique) et les entrées. Encore une fois, ceci est bas niveau et lorsque vous créez des jeux avec Godot, écrire votre propre MainLoop a rarement du sens.

ArbreDesScènes¶

L'un des manières d'expliquer comment Godot fonctionne est qu'il est un moteur de jeu de haut niveau, construit par-dessus un middleware de bas niveau.

Le système de gestion de scènes est le game engine, tandis que OS et les serveurs sont partis de l'API de bas niveau.

Le système de scène fournit sa propre boucle principale à l'OS, SceneTree. Elle est automatiquement instanciée et configurée lors de l'exécution d'une scène, aucun travail supplémentaire est nécessaire.

Il est important de savoir que cette classe existe car elle a des utilisations importantes :

Elle contient le Viewport racine, à laquelle une scène est ajoutée en tant qu'enfant lorsqu'elle est ouverte pour la première fois, afin de faire partie de l'arborescence de scène Scene Tree (plus d'informations là-dessus par la suite).
Elle contient des informations sur les groupes et permet d'appeler tous les nœuds d'un groupe ou d'obtenir une liste de ceux-ci.
Elle contient certaines fonctionnalités d'état global, comme le réglage du mode pause ou quitter le processus.

Lorsqu'un nœud fait partie de l'arbre des scènes, le singleton SceneTree peut être obtenu en appelant simplement Node.get_tree().

Le viewport racine¶

Le Viewport racine est toujours en haut de la scène. A partir d'un nœud, il peut être obtenu de deux manières différentes :

get_tree().get_root() # Access via scene main loop.
get_node("/root") # Access via absolute path.

GetTree().GetRoot(); // Access via scene main loop.
GetNode("/root"); // Access via absolute path.

Ce nœud contient la fenêtre d'affichage principale. Tout ce qui est un enfant d'un Viewport est dessiné à l'intérieur de celui-ci par défaut, il est donc logique que le nœud en amont de tous les autres soit toujours un nœud de ce type, sinon rien ne serait vu.

Alors que d'autres viewports peuvent être créés dans la scène (pour des effets d'écran partagé et autres), celui-ci est le seul qui n'est jamais créé par l'utilisateur. Il est créé automatiquement à l'intérieur de SceneTree.

Scene tree (Arbre de scène)¶

Lorsqu'un nœud est connecté, directement ou indirectement, au viewport racine, il fait partie de l'arborescence des scènes.

Cela signifie que, comme expliqué dans les tutoriels précédents, il recevra les rappels de _enter_tree() et _ready() (ainsi que _exit_tree()).

Lorsque les nœuds entrent dans l'arbre de scène, ils deviennent actifs. Ils ont accès à tout ce dont ils ont besoin pour fonctionner, obtenir des entrées, afficher des données en 2D et 3D, recevoir et envoyer des notifications, jouer du son, etc. Lorsqu'ils sont retirés de l'arbre de scène, ils perdent cet accès.

Ordre de l'arborescence¶

La plupart des opérations de nœuds dans Godot, comme le dessin 2D, le traitement ou l'obtention de notifications se font dans l'ordre de l'arborescence. Cela signifie que les parents et les frères et sœurs ayant un rang inférieur dans l'ordre de l'arborescence seront notifiés avant le nœud courant.

"Activation" en entrant dans l'arbre de scène (Scene Tree)¶

Une scène est chargée à partir du disque ou créée par un script.
Le nœud racine de cette scène (une seule racine, vous souvenez-vous ?) est ajouté soit comme un enfant du Viewport "racine" (de SceneTree), soit à tout enfant ou petit-enfant de celui-ci.
Chaque nœud de la scène nouvellement ajoutée recevra la notification "enter_tree" (fonction de rappel _enter_tree() dans GDScript) dans l'ordre haut vers bas.
Une notification supplémentaire, "ready" (fonction de rappel _ready() dans GDScript) est fournie par commodité, lorsqu'un nœud et tous ses enfants sont à l'intérieur de la scène active.
Quand une scène (ou une partie de celle-ci) est supprimée, ils reçoivent la notification "exit scene" (fonction de rappel _exit_tree() dans GDScript) dans l'ordre bas vers haut

Changement de la scène courante¶

Après qu'une scène soit chargée, il est souvent souhaitable de la remplacer par une autre. La façon la plus simple de le faire est d'utiliser la fonction SceneTree.change_scene() :

func _my_level_was_completed():
    get_tree().change_scene("res://levels/level2.tscn")

public void _MyLevelWasCompleted()
{
    GetTree().ChangeScene("res://levels/level2.tscn");
}

Au lieu d'utiliser des chemins de fichiers, vous pouvez aussi utiliser une ressource déjà prête PackedScene en utilisant la fonction équivalente SceneTree.change_scene_to(PackedScene scene) :

var next_scene = preload("res://levels/level2.tscn")

func _my_level_was_completed():
    get_tree().change_scene_to(next_scene)

public void _MyLevelWasCompleted()
{
    var nextScene = (PackedScene)ResourceLoader.Load("res://levels/level2.tscn");
    GetTree().ChangeSceneTo(nextScene);
}

Ce sont des façons rapides et utiles de passer d'une scène à une autre mais qui ont l'inconvénient que le jeu va devoir attendre jusqu'à ce que la nouvelle scène soit chargée et fonctionne. À un moment donné, dans le développement de votre jeu, vous souhaiterez peut-être créer des écrans de chargement avec une barre de progression, indicateurs animés ou chargement via un autre thread (en arrière-plan). Cela doit être fait manuellement en utilisant des "autoloads" (voir le chapitre suivant) et Chargement en arrière-plan.