Logo
latest

Général

  • À propos
    • Introduction
      • Avant de commencer
      • À propos de Godot Engine
      • À propos de la documentation
      • Organisation de la documentation
    • Question fréquentes
      • Que puis-je faire avec Godot ? Combien coûte-t-il ? Quels sont les termes de la licence ?
      • Quelles plateformes sont supportées par Godot ?
      • Quels langages de programmation sont supportés par Godot ?
      • Qu’est-ce que le GDScript et pourquoi devrais-je l’utiliser ?
      • Qu’est-ce qui a motivé la création de GDScript ?
      • Quels types de formats de modèles 3D sont pris en charge par Godot ?
      • Est-ce que [Insérer un SDK fermé tel que FMOD, GameWorks, etc.] sera un jour, supporté dans Godot ?
      • Comment créer des ressources pour gérer plusieurs résolutions et rapports d’aspect ?
      • Comment puis-je améliorer Godot ?
      • J’aimerai contribuer ! Où puis-je commencer ?
      • J’ai une super idée pour Godot. Comment puis-je la partager ?
      • Pourquoi Godot n’utilise pas la STL (Standard Template Library)
      • Pourquoi n’y a-t-il pas de gestion d’exceptions dans Godot ?
      • Pourquoi Godot Engine ne renforce pas le RTTI (Run-time type information) ?
      • Pourquoi Godot Engine ne force t il pas les utilisateurs a implémenter le DoD (Data oriented Design) ?
      • Comment puis-je soutenir le développement de Godot ou y contribuer ?
      • Qui travaille sur Godot ? Comment puis-je vous contacter ?
    • Changelog de la documentation
      • Nouveaux tutoriels depuis la version 3.1
        • Gestion de projet
        • 2D
        • Audio
        • Maths
        • Contrôles
        • Internationalisation
        • Ombres
        • Réseau
        • Extensions
        • Le Multi-threading
        • Création de contenu
        • Optimisation
        • Légal
      • Nouveaux tutoriels depuis la version 3.0
        • Pas à pas
        • Les scripts
        • Gestion de projet
        • 2D
        • 3D
        • Physique
        • Animation
        • Interface graphique
        • Fenêtre d’aperçu (Viewports)
        • Ombres
        • Réalité virtuelle
        • Extensions
        • Propre à une plateforme
        • Le Multi-threading
        • Création de contenu
        • Divers
        • Compilation
        • Développement du moteur

Prise en main

  • Pas à pas
    • Introduction à l’éditeur de Godot
      • Gestionnaire de projets
        • Créer ou importer un projet
      • Premiers pas avec l’éditeur de Godot
      • Les fenêtres d’affichage
      • Modifier l’interface
        • Déplacer et redimensionner les docks
    • Des scènes et des nœuds
      • Introduction
      • Les nœuds
      • Les scènes
      • Créer un nouveau projet
      • Éditeur
      • Configurer le projet
      • À suivre…
    • Instancier
      • Introduction
      • L’instanciation par l’exemple
      • Instances multiples
      • Éditer des instances
      • Conclusion
    • L’instanciation (suite)
      • Récapitulatif
      • Langage de conception
      • Surcharge d’informations !
    • Les scripts
      • Introduction
        • GDScript
        • VisualScript
        • .NET / C#
        • GDNative / C++
      • Scripter une scène
        • Configuration de la scène
        • Ajouter un script
        • Le rôle du script
        • Traitement d’un signal
    • Scripting (suite)
      • Traitement
      • Groupes
      • Notifications
      • Fonctions surchargeables
      • Création de nœuds
      • Instancier des scènes
      • Enregistrer des scripts en tant que classes
    • Signaux
      • Introduction
      • Exemple de minuterie
        • Connecter des signaux dans le code
      • Signaux personnalisés
      • Conclusion
    • Votre premier jeu
      • Vue d’ensemble
      • Configuration du projet
        • Organisation du projet
      • Scène Player
        • Structure des nœuds
        • Animation du sprite
        • Déplacer le joueur
        • Choisir les animations
        • Préparer aux collisions
      • Scène de l’ennemi
        • Configuration du nœud
        • Script de l’ennemi
      • Scène principale
        • Générer des monstres
        • Script principal
      • HUD
        • ScoreLabel
        • MessageLabel
        • StartButton
        • Connecter le HUD au Main
        • Supprimer les vieux Creeps
      • Pour terminer
        • Arrière-plan
        • Effets sonores
        • Raccourci clavier
      • Fichiers du projet
    • Exportation
      • Vue d’ensemble
      • Préparation du projet
      • Exporter des modèles
      • Réglages d’export par défaut
      • Exporter par plateforme
        • PC (Linux / macOS / Windows)
        • Android
        • iOS
        • HTML5 (web)
    • La philosophie de conception de Godot
      • Conception et composition orientées objet
      • Forfait tout compris
      • Libre
      • Géré par une communauté
      • L’éditeur Godot est un jeu Godot
      • Moteurs 2D et 3D séparés
    • Conception d’interfaces avec les nœuds Control
      • Les 5 éléments les plus courants de l’interface utilisateur
        • TextureRect
        • TextureButton
        • TextureProgress
        • Label
        • NinePatchRect
      • Il existe deux méthodes de travail pour créer des interfaces utilisateur réactives
      • Placer précisément les éléments de l’interface utilisateur à l’aide d’ancrages
        • Comment modifier l’ancrage
        • Les ancrages sont relatifs à leur conteneur parent
        • Les marges changent avec l’ancrage
        • Utilisez les balises de taille pour modifier la façon dont les éléments de l’interface utilisateur remplissent l’espace disponible
      • Arrangez automatiquement les nœuds de contrôle avec les conteneurs
        • Les 5 conteneurs les plus utiles
    • Concevoir un écran titre
      • Comment concevoir l’interface utilisateur de votre jeu
      • Construire le menu principal
        • Décomposez la maquette de l’interface utilisateur
        • Prépare la scène du Menu Principal
        • Ajoutez les sprites de l’interface
        • Ajoutez des conteneurs pour placer automatiquement les éléments de l’interface utilisateur
        • Décomposez la maquette de l’interface utilisateur
    • Créer la GUI
      • Décomposer l’interface utilisateur
      • Créer les bases de l’IHM
        • Créez la base des barres
        • Remplacer la police du label
        • Ajouter une bar de progresssion
      • Créer les compteurs de bombes et d’émeraudes
      • Transformer la barre et le compteur en composants d’interface graphique réutilisables
      • Utilisez l’héritage de scène pour créer les éléments restants
        • Hériter de la scène Bar pour construire la barre de vie
        • Créer la barre d’énergie
        • Préparer les compteurs de bombes et d’émeraudes
      • Ajouter les composants de l’interface utilisateur à l’interface graphique finale
      • Placez l’interface graphique sur la maquette du jeu
    • Contrôler l’interface utilisateur du jeu avec du code
      • Introduction
      • Télécharger et explorer le projet de démarrage
      • Initialiser la barre de vie avec la valeur maximale de vie du joueur
      • Mettre à jour la santé avec un signal lorsque le joueur prend un coup
      • Animer la perte de vie avec un nœud Tween
      • Assigner animated_health à la barre de vie
      • Réaliser un fondu de la barre quand le joueur meurt
    • Écran de lancement
      • Tutoriel
      • Mise en place
    • Animations
      • Introduction
      • Ajouter un lecteur d’animation
      • Créer l’animation
      • Éditer l’animation
    • Ressources
      • Nœuds et ressources
      • Externe vs intégré
      • Chargement de ressources à partir du code
      • Chargement de scènes
      • Libérer des ressources
      • Créer vos propres ressources
    • Système de fichiers
      • Introduction
      • Implémentation
      • project.godot
      • Délimiteur de chemin d’accès (Path delimiter)
      • Chemin des ressources (Resource path)
      • Chemin de l’utilisateur (User path)
      • Système de fichier hôte (Host file system)
      • Inconvénients
    • L’arbre de scène
      • Introduction
      • Boucle événementielle
      • L’arbre de scène
      • La fenêtre d’affichage racine
      • Arbre de scène
      • Ordre de l’arborescence
      • « Activation » en entrant dans l”arbre de scène
      • Changement de la scène courante
    • Singletons (Chargement Automatique)
      • Introduction
      • AutoLoad
      • Sélecteur de scène personnalisé
        • Global.gd
  • Manuel de l’éditeur
    • De Unity à Godot Engine
      • Différences
      • L’éditeur
      • Le système de scène
      • Organisation du projet
      • Où sont mes prefabs (préfabriqués) ?
      • Correspondance de glossaire
      • Scripting: GDScript, C# et Visual Script
        • Conception
        • Connexions : groupes et signaux
        • Sérialisation de scripts
      • Utiliser Godot en C ++
    • Tutoriel de ligne de commande
      • Command line reference
      • Chemin
      • Définir le chemin du projet
      • Créer un projet
      • Exécution de l’éditeur
      • Effacer une scène
      • Éxécuter le jeu
      • Débogage
      • Exportation
      • Exécuter un script
    • Utiliser un éditeur de texte externe
  • Les scripts
    • GDScript
      • GDScript basics
        • Introduction
        • Langage
        • Types intégrés
        • Données
      • GDScript : Une introduction aux langages dynamiques
        • À propos
        • Nature dynamique
        • Les tableaux
        • Les dictionnaires
        • Boucles for et while
        • Tant que
        • Itérateurs personnalisés
        • Le typage canard (duck typing)
      • Exportations GDScript
        • Introduction à l’exportation
        • Exemples
        • Exportation des indicateurs binaires
        • Exportation de tableaux
      • Guide de style GDScript
        • Description
        • Structure de code
        • Conventions de nommage
        • typage statique
      • Typage statique en GDScript
        • Un bref aperçu de la saisie statique
        • Comment utiliser le typage statique
        • Typé ou dynamique: s’en tenir à un style
        • Système d’avertissement
        • Cas où vous ne pouvez pas spécifier de types
        • Résumé
      • Chaînes de format GDScript
        • Utilisation en GDScript
        • Espaces réservés multiples
        • Les spécificateurs de format
        • Remplissage
        • Séquence d’échappement
        • Exemples de méthodes de formatage
    • VisualScript
      • Qu’est-ce que le Visual Scripting ?
      • Démarrer avec Visual Scripting
        • Création d’un script
        • Ajouter une fonction
      • Nœuds et terminologie
        • Propriétés d’un nœud
        • Ports et connexions
        • Ajouter des nœuds
        • Ajouter d’autres nœuds
    • C#
      • Introduction
        • Configurer C# pour Godot
        • Configuration d’un éditeur externe
        • Création d’un script C#
        • Mise en place du projet et flux de travail
        • Exemple
        • Différences générales entre C# et GDScript
        • Les pièges courants et les problèmes connus
        • Performance du C# dans Godot
        • Utilisation des packages Nuget dans Godot
      • Fonctionnalités
        • Conversion de type et Casting
        • Signaux C#
      • Différences de l’API par rapport à GDScript
        • Différences générales
        • Portée globale
        • Mot-clé d’exportation
        • Mot-clé de signal
        • Singletons
        • Chaîne de caractères
        • Basis
        • Transform2D
        • Plane
        • Rect2
        • Quat
        • Tableau
        • Dictionnaire
        • Variant
        • Communiquer avec d’autres langages de script
        • Yield
        • Autres différences
      • Guide de style C#
        • Spécification du langage
        • Conventions de formatage
        • Retours de ligne et lignes vierges
        • Utilisation des espaces
        • Conventions de nommage
        • Variables locales implicitement typées
        • Autres considérations
  • Gestion de projet
    • Configuration du projet
      • Organisation du projet
        • Introduction
        • Organisation
        • Importation
    • Gestion des assets
      • Processus d’importation
        • Importer des ressources dans Godot 3.0+
        • Changer les paramètres d’importation
        • Réimportation automatique
        • Fichiers générés
        • Changer le type d’importation de ressource
        • Changer les paramètres d’importation par défaut
        • La simplicité est la clé !
      • Importer des images
        • Pourquoi les importer ?
        • Importer des textures
        • Compression
        • Drapeaux
        • Traitement
      • Importer des échantillons audio
        • Pourquoi importer ?
        • Les meilleures pratiques
      • Importation de traductions
        • Jeux et internationalisation
        • Format de traduction
        • Import CSV
      • Importation de scènes 3D
        • Importateur de scènes Godot
        • Processus d’importation
        • Options d’importation
        • Options d’animation
        • Héritage de scène
        • Conseils pour l’importation
      • Blender ESCN exportateur
        • Détails sur l’exportation
        • Désactiver des objets spécifiques
        • Construire l’intégration au pipeline
    • Exporter
      • Exporter des projets
        • Pourquoi exporter ?
        • Menu d’exportation
        • Exporter à partir de la ligne de commande
      • Exporter des packs, des patchs, et des mods
        • Cas d’utilisations
        • Vue d’ensemble des fichiers PCK
        • Générer des fichiers PCK
        • Ouvrir des fichiers PCK à l’exécution
        • Résumé
      • Tags de fonctionnalité
        • Introduction
        • Fonctionnalités par défaut
        • Fonctionnalités personnalisées
        • Écraser les paramètres du projet
        • Écrasements par défaut
        • Personnalisation de la compilation
      • Exportation pour PC
      • Exporter pour IOS
        • Pré-requis
        • Exporter un projet vers Xcode
        • Considérations actives lors du développement
        • Services pour iOS
      • Exportation pour la plateforme Windows universelle (UWP)
        • Limitations sur Xbox One
        • Création d’un certificat de signature
        • Signer le paquet
        • Installation du paquetage
      • Exporter pour Android
        • Télécharger le SDK Android
        • Installer OpenJDK ou Oracle JDK
        • Créer un keystore (magasin de clefs) de débogage
        • Assurez-vous d’avoir adb
        • La mise en place dans Godot
        • Exporter pour le Google Play Store
        • Optimiser la taille du fichier APK
      • Exporter pour le Web
        • WebGL 2
        • Limites
        • Distribuer les fichiers
        • Options d’exportation
        • Appel de JavaScript depuis un script
      • Déploiement en un clic
        • Ça a l’air bien, qu’est-ce que c’est ?
        • Étapes de déploiement en un clic
      • Builds personnalisées pour Android
        • Configurer l’environnement de construction sur mesure
        • Installer le SDK Android (version en ligne de commande)
        • Installer le SDK Android (Android Studio)
        • Activation de la génération et de l’exportation personnalisées
      • Changer l’icone de l’application pour windows
        • Changer l’icône de la barre des tâches
        • Changer l’icône du fichier
        • Tester le résultat
        • Exigences des fichiers icônes (ICO)
    • Les meilleures pratiques
      • Introduction
      • Les scènes de Godot et les scripts sont des classes
        • Donner un sens aux classes dans Godot
        • Performances des scripts et PackedScene
        • Scenes et scripts sont des objets
      • Organisation de la scène
        • Comment établir des relations efficacement
        • Choix d’une structure d’arborescence de nœud
      • Quand utiliser des scènes ou des scripts ?
        • Types anonymes
        • Types nommés
        • Conclusion
      • Chargements automatiques par rapport aux nœuds internes
      • Quand et comment éviter d’utiliser des nœuds pour tout
      • Interfaces de Godot
        • Acquisition de références d’objets
        • Accès aux données ou à la logique à partir d’un objet
      • Notifications Godot
        • _process vs. _physics_process vs. *_input
        • _init vs. initialization vs. export
        • _ready vs. _enter_tree vs. NOTIFICATION_PARENTED
      • Préférences de données
        • Array vs. Dictionary vs. Object
        • Énumérations : int vs string
        • AnimatedTexture vs. AnimatedSprite vs. AnimationPlayer vs. AnimationTree
      • Préférences de logique
        • Chargement vs préchargement
        • Grands niveaux : statique vs dynamique

Tutoriels

  • 2D
    • Couches du canevas
      • Eléments de fenêtre et de canevas
      • Couches de canevas
    • Modifications de la fenêtre d’affichage et du canevas
      • Introduction
      • Transformation du canevas
      • Transformation globale du canevas
      • Transformation par étirement
      • Ordre de transformation
      • Fonctions de transformation
      • Alimentation d’événements d’entrées personnalisés
    • Utiliser les palettes de tuiles
      • Introduction
      • Configuration du projet
      • Nœud TileMap
      • Créer un jeu de tuiles
      • Formes de collisions
      • Atlas de Tuile
      • Trucs et Astuces
    • Systèmes de particules (2D)
      • Introduction
        • Nœuds de particules
        • ParticlesMaterial
        • Texture
      • Paramètres de temps
        • Durée de vie
        • Un coup
        • Prétraitement
        • Échelle de vitesse
        • Explosivité
        • Aléatoire
        • FPS donné
        • Fract Delta
      • Paramètres de dessin
        • Rectangle de visibilité
        • Coordonnées locales
        • Ordre de dessin
      • Paramètres de ParticlesMaterial
        • Propagation
        • Gravité
        • Vélocité initiale
        • Vitesse angulaire
        • Vitesse de rotation
        • Vitesse Orbitale
        • Accélération linéaire
        • Accélération radiale
        • Accélération Tangentielle
        • Amortissement
        • Angle
        • Scale
        • Couleur
        • Variation de teinte
      • Formes d’émission
        • Masque d’émission
        • Couleurs d’émission
    • Vue d’ensemble du mouvement 2D
      • Introduction
      • Configuration
      • Mouvement 8 directions
      • Rotation + Mouvement
      • Rotation + Mouvement (souris)
      • Cliquer-et-déplacer
      • Résumé
    • Lumières et Ombres 2D
      • Introduction
      • Configuration
      • Les nœuds
      • Lumières
      • Ombres
      • Pas à pas
    • Maillages 2D
      • Introduction
      • Optimisation le dessin de pixels
      • Conversion de Sprites en maillages 2D
    • Dessin personnalisé en 2D
      • Pourquoi ?
      • Mais…
      • D’accord, comment ?
      • Mise à jour
      • Un exemple: dessiner des arcs de cercle
        • Fonction d’arc
        • Dessiner l’arc à l’écran
        • Fonction de polygone d’arc
        • Dessin personnalisé dynamique
      • Outils
    • Animation de Sprite 2D
      • Introduction
      • Images individuelles avec AnimatedSprite
        • Contrôle de l’animation
      • Feuille de Sprite avec AnimationPlayer
        • Controlling an AnimationPlayer animation
      • Résumé
  • 3D
    • Introduction à la 3D
      • Nœud spatial
      • Contenu 3D
        • Modèles créés par DCC
        • Géométrie générée
        • Géométrie immédiate
        • 2D en 3D
      • Environnement
      • Fenêtre d’affichage 3D
        • Système de coordonnées
        • Espace et gadgets de manipulation
        • Menu affichage
        • Environnement par défaut
        • Caméras
        • Lumières
    • Utilisation des transformations 3D
      • Introduction
      • Problèmes des angles d’Euler
        • Ordre des axes
        • Interpolation
        • Dîtes non aux angles d’Euler
      • Introduction aux transformations
        • Manipuler les transformations
        • Erreurs de précision
        • Obtenir l’information
        • Informations de réglage
        • Interpoler avec des quaternions
      • Les transformations sont vos amies
    • Performances et limitions de la 3D
      • Introduction
      • Rendu
        • Réutilisation des shaders et des matériaux
        • Coût en pixel contre coût en sommet
        • Compression de texture
        • Objets transparents
        • Niveau de détail (LOD)
        • Utiliser l’instanciation (MultiMesh)
        • Préparation de l’éclairage
    • Spatial Material
      • Introduction
      • Drapeaux
        • Transparent
        • Utiliser l’ombre pour l’opacité
        • Sans ombre
        • Éclairage de sommet
        • Aucun test de profondeur
        • Utiliser la taille de point
        • Monde Triplanaire
        • Taille fixe
        • Ne pas recevoir d’ombres
        • Désactiver la lumière ambiante
        • Ensure Correct Normals
      • Couleur de sommet
        • Utiliser comme albedo
        • Est sRGB
      • Paramètres
        • Mode diffus
        • Mode spéculaire
        • Mode de fusion
        • Mode de Culling
        • Mode de dessin en profondeur
        • Largeur de ligne
        • Taille de point
        • Mode Billboard
        • Billboard Keep Scale
        • Croître
        • Utiliser Alpha Scissor
      • Couleurs des matériaux, cartes et canaux
        • Albedo
        • Métallique
        • Rugosité
        • Émission
        • Normalmap
        • Rim
        • Vernis transparent
        • Anisotropie
        • Occlusion ambiante
        • Profondeur
        • Diffusion souterraine
        • Transmission
        • Réfraction
        • Détail
        • UV1 et UV2
        • Cartographie triplanaire
      • Fondu de proximité et distance
      • Priorité de rendu
    • Lumières et Ombres
      • Introduction
      • Nœuds de lumière
        • Cartographie des ombres
        • Cartographie des ombres directionnelles
        • Cartographie des ombres de Omni lights
        • Cartographie des ombres de Spot lights
    • Reflection probes
      • Introduction
      • Mise en place
      • Intérieur vs extérieur
      • Mélange
      • Atlas de réflexion
    • GI Probes
      • Introduction
      • Mise en place
      • Ajout de lumières
      • Réflexions
      • Intérieur vs extérieur
      • Ajustement
      • Qualité
    • Baked lightmaps
      • Introduction
      • Comparaison visuelle
      • Mise en place
        • Déplier depuis votre logiciel 3D
        • Dépliage depuis Godot
        • Dépliage d’une scène importée
        • Vérification UV2
      • Mise en place de la scène
        • Configurer les limites
        • Mise en place des maillages
        • Mise en place des lumières
        • Qualité de « Baking »
      • Pré-calcul
        • Configurer les pré-calculs
      • Objets dynamiques
    • Environnement et post-traitement
      • Environnement
        • Nœud Camera
        • Nœud WorldEnvironnement
        • Environnement par défaut
      • Options d’environnement
        • Arrière-plan
        • Lumière ambiante
        • Brouillard
        • Tonemap
        • Exposition automatique (HDR)
      • Effets de mi et post-traitement
        • Screen-Space Reflections (SSR)
        • Screen-Space Ambient Occlusion (SSAO)
        • Profondeur de champ / Flou lointain
        • Profondeur de champ / flou de proximité
        • Lueur
        • Ajustements
    • Transport de lumière dans les moteurs de jeu
      • Introduction
      • Écrans d’ordinateur
      • Scène linéaire et pipelines de ressources
        • Fonction de transfert sRGB pour afficher les rapports linéaires lors de l’importation d’images
        • Fonction de transfert matériel sRGB pour afficher la conversion linéaire
        • Scene linear to display referred nonlinear
      • Paramètres de HDR
    • Utilisation de gridmaps
      • Introduction
      • Exemple de projets
      • Création d’une MeshLibrary
      • Collisions
      • Matériaux
      • Exportation de la MeshLibrary
      • Utilisation de GridMap
      • Utiliser GridMap dans le code
    • Utilisation de MultiMeshInstance
      • Introduction
      • Configuration des nœuds
      • Paramètres MultiMesh
        • Surface cible
        • Maillage source
        • Mesh Up Axis
        • Rotation aléatoire
        • Inclinaison aléatoire
        • Échelle aléatoire
        • Scale
        • Amount
    • CSG
      • Introduction aux nœuds CSG
        • Fonctionnalités des outils CSG
        • CSGPolygon
        • Maillages personnalisés
        • CSGCombiner
        • Ordre de traitement
      • Prototypage d’un niveau
    • Jeu à la première personne
      • Partie 1
        • Tutoriel d’introduction
        • Aperçu cette partie
        • Tout préparer
        • Faire la logique de mouvement FPS
        • Donner au joueur une lampe flash et la possibilité de sprinter
        • Notes finales
      • Partie 2
        • Aperçu cette partie
        • Réalisation d’un système de traitement des animations
        • Préparation des animations
        • Créer la scène balle
        • Créer la première arme
        • Création des deux autres armes
        • Faire fonctionner les armes
        • Création de quelques sujets de tests
        • Notes finales
      • Partie 3
        • Aperçu cette partie
        • Changement des niveaux
        • Ajout des munitions
        • Ajout du rechargement des armes
        • Ajout du rechargement au joueur
        • Ajouter des sons
        • Notes finales
      • Partie 4
        • Aperçu cette partie
        • Ajout des contrôles de manette
        • Ajouter une entrée pour la molette de la souris
        • Ajouter des vies ramassables
        • Ajouter des munitions ramassables
        • Ajouter des cibles destructibles
        • Notes finales
      • Partie 5
        • Aperçu cette partie
        • Ajouter les grenades
        • Ajouter des grenades au joueur
        • Ajout de la capacité d’attraper et lancer des nœuds RigidBody au joueur
        • Ajouter une tourelle
        • Notes finales
      • Partie 6
        • Aperçu cette partie
        • Ajouter le menu principal
        • Créer le singleton Globals
        • Ajouter le menu de débogage
        • Ajouter un menu de pause
        • Commencer le système de réapparition
        • Terminer le système de réapparition
        • Écrire un système de son qui puisse être utilisé partout
        • Notes finales
    • Animer des milliers d’objets
      • Animer des milliers de poissons avec MultiMeshInstance
        • Animation d’un poisson
        • Faire un banc de poissons
        • Animer un banc de poisson
      • Contrôler des milliers de poissons avec des particules
  • Audio
    • Bus audio
      • Introduction
      • Échelle de décibels
      • Bus audio
      • Lecture de l’audio à travers un bus
      • Ajouter des effets
        • Amplifier (Amplify)
        • Limite de Bande et Passe-Bande (BandLimit and BandPass)
        • Chœur (Chorus)
        • Compresseur (Compressor)
        • Délai (Delay)
        • Distorsion (Distortion)
        • EQ
        • EQ6, EQ10, EQ21
        • Filtre
        • Filtre passe-haut, filtre plateau haut (HighPassFilter, HighShelfFilter)
        • Limiteur (Limiter)
        • Filtre passe-bas, filtre plateau bas (LowPassFilter, LowShelfFilter)
        • Filtre coupe-bande (NotchFilter)
        • Panner
        • Phaser
        • Changement de hauteur (PitchShift)
        • Enregistrer (Record)
        • Réverbération (Reverb)
        • SpectrumAnalyzer
        • Amélioration Stéréo (StereoEnhance)
      • Désactivation automatique du bus
      • Réarrangement de bus
      • Disposition des bus par défaut
    • Flux audio
      • Introduction
      • Flux audio
      • AudioStreamPlayer (=LecteurAudio)
      • AudioStreamPlayer2D (=LecteurAudio2d)
      • AudioStreamPlayer3D (=LecteurAudio3d)
        • Bus de réverbération
        • Effet Doppler
    • Synchronisez le jeu avec les sons et la musique
      • Introduction
      • Utilisation de l’horloge système pour la synchronisation
      • Utilisation de l’horloge matérielle du son pour la synchronisation
    • Recording with microphone
      • The structure of the demo
  • Physique
    • Introduction à la physique
      • Objets de collisions
        • Formes de collisions
        • Rappel des processus physiques
        • Niveaux et masques de collisions
      • Area2D
      • StaticBody2D
      • RigidBody2D
        • Modes corps rigides
        • Utiliser RigidBody2D
        • Rapport de contact
      • KinematicBody2D
        • Réponse cinématique à la collision
    • RigidBody
      • Qu’est-ce qu’un corps rigide ?
      • Comment contrôler un corps rigide
      • La méthode « look at »
    • Utilisation de Area2D
      • Introduction
      • Qu’est-ce qu’une zone ?
      • Propriétés de zone
      • Détection de chevauchement
      • Influence de la zone
        • Point gravity
        • Exemples
    • Utilisation de KinematicBody2D
      • Introduction
      • Qu’est-ce qu’un kinematic body ?
      • Mouvement et collision
        • move_and_collide
        • move_and_slide
        • move_and_slide_with_snap
      • Quelle méthode de mouvement utiliser ?
      • Exemples
        • Mouvement et murs
        • Rebondir/se réfléchir
        • Mouvement de jeu de plateforme
    • Lancer de rayons
      • Introduction
      • Espace
      • Accéder à l’espace
      • Requête Raycast
      • Exceptions de collision
      • Masque de collision
      • Ray casting 3D à partir de l’écran
    • Système Ragdoll
      • Introduction
      • La configuration du ragdoll
        • Créer des os physiques
        • Nettoyer le squelette
        • Ajustement de la forme de collision
        • Ajustement des joints
      • Simuler le ragdoll
        • Niveau et masque de collision
    • Personnage cinématique (2D)
      • Introduction
      • Processus physique
      • Configuration de la scène
      • Déplacer le personnage cinématique
    • SoftBody
      • Configuration de base
      • Simulation de cape
  • Maths
    • Mathématiques vectorielles
      • Introduction
      • Systèmes de coordonnées (2D)
      • Opérations vectorielles
        • Accès aux membres
        • Additionner des vecteurs
        • Multiplication scalaire
      • Applications pratiques
        • Mouvement
        • Pointer vers une cible
      • Vecteurs unitaires
        • Normalisation
        • Réflexion
      • Produit scalaire
        • Orienté vers
      • Produit Vectoriel
        • Calcul des normales
        • Pointer vers une cible
      • Plus d’information
    • Mathématiques vectorielles avancées
      • Plans
        • Distance par rapport au plan
        • Loin de l’origine
        • Construire un plan en 2D
        • quelques exemples de plan
      • Détection des collisions en 3D
    • Matrices et transformations
      • Introduction
      • Système de coordonnées orienté (OCS)
      • Basis
      • Transforms in Godot
        • Transform2D
        • Identity
      • Operations
        • Rotation
        • Translation
        • Local to global coordinates and vice versa
        • Scale
        • Transformation
        • Transformation inverse
        • Affine inverse
        • Multiplication de matrice
        • Multiplication par l’inverse
        • Multiplication par l’identité
      • Les astuces de matrice
      • Matrices & transforms in 3D
        • Basis
        • Rotation in 3D
        • Transformation
    • Interpolation
      • Interpolation vectorielle
      • Interpolation par transformation
      • Mouvement lisser
    • Beziers, curves and paths
      • Quadratic Bezier
      • Cubic Bezier
      • Ajout de points de contrôle
      • Curve2D, Curve3D, Path and Path2D
      • Evaluating
      • Drawing
      • Traversal
  • Animation
    • Introduction to the 2D animation features
      • Vue d’ensemble
      • Create an AnimationPlayer node
      • Computer animation relies on keyframes
      • Tutorial: Creating a simple animation
        • Configuration de la scène
        • Adding a track
        • The second keyframe
        • Run the animation
        • Back and forth
        • Track settings
      • Keyframes for other properties
      • Edit keyframes
      • Advanced: Call Method tracks
    • Cutout animation
      • What is it?
      • Cutout animation in Godot
      • Fabrication de GBot
      • Setting up the rig
      • Adjusting the pivot
      • RemoteTransform2D node
      • Completing the skeleton
      • Skeletons
      • IK chains
      • Astuces d’animation
        • Définition des images-clés et exclusion des propriétés
      • Créer une position de repos
      • Modifying rotation only
      • Keyframing IK chains
      • Visually move a sprite behind its parent
      • Setting easing curves for multiple keys
      • 2D Skeletal deform
    • Squelettes 2D
      • Introduction
      • Configuration
      • Créer les polygones
      • Créer le squelette
      • Déformer les polygones
      • Sommets internes
    • AnimationTree
      • Introduction
      • Créer un AnimationTree
      • Création d’une arborescence
      • Arbre de mélange
        • Blend2 / Blend3
        • OneShot
        • Seek
        • TimeScale
        • Transition
        • BlendSpace2D
        • BlendSpace1D
        • StateMachine
      • Racine de mouvement
      • Controlling from code
      • State machine travel
  • Contrôles
    • InputEvent
      • What is it?
      • How does it work?
      • Anatomy of an InputEvent
      • Actions
      • InputMap
    • Exemples d’entrée
      • Introduction
      • Events versus polling
      • Événement d’entrée
      • InputMap
        • Capturer les actions
      • Événements clavier
        • Modificateurs de clavier
      • Événements souris
        • Mouse buttons
        • Mouvement de la souris
      • Événements tactiles
    • Mouse and input coordinates
      • À propos
      • Hardware display coordinates
      • Viewport display coordinates
    • Customizing mouse cursor
      • Using project settings
      • Using a script
      • Demo project
      • Cursor list
  • Entrée/Sortie
    • Background loading
      • ResourceInteractiveLoader
      • Utilisation
        • Obtaining a ResourceInteractiveLoader
        • Polling
        • Load progress (optional)
        • Forcing completion (optional)
        • Obtaining the resource
      • Exemple
      • Using multiple threads
        • Use a semaphore
        • Not blocking main thread during the polling
      • Example class
        • Exemple :
    • Data paths
      • Path separators
      • Chemin des ressources (Resource path)
      • User path (persistent data)
      • Chemins de données de l’éditeur
        • Self-contained mode
    • Saving games
      • Introduction
      • Identify persistent objects
      • Serializing
      • Saving and reading data
      • Some notes
    • Encrypting save games
      • Pourquoi ?
      • How?
  • Internationalisation
    • Internationaliser des jeux
      • Introduction
      • Configuring the imported translation
      • Localizing resources
      • Converting keys to text
      • Making controls resizable
      • TranslationServer
      • Command line
      • Translating the project name
    • Localisation à l’aide de gettext
      • Avantages
      • Désavantages
      • Caveats
      • Installation des outils gettext
      • Création manuelle du modèle PO (POT)
      • Création du modèle PO (POT) à l’aide de pybabel
      • Creating a messages file from a PO template
      • Chargement d’un fichier de messages dans Godot
      • Updating message files to follow the PO template
      • Checking the validity of a PO file or template
    • Versions de langues
  • Interface graphique
    • GUI skinning
      • Oh, beautiful GUI!
      • Thème
      • Theme options
      • Customizing a control
      • Creating a theme
      • Example: theming a button
    • Custom GUI controls
      • So many controls…
      • Drawing
        • Checking control size
        • Checking focus
      • Sizing
      • Entrée
        • Événement d’entrée
        • Notifications
    • Size and anchors
      • Centrage d’un contrôle
    • Containers
      • Conteneurs de disposition
      • Drapeaux de taille
      • Types de conteneurs
        • Box Containers
        • Grid Container
        • Margin Container
        • Tab Container
        • Split Container
        • PanelContainer
        • ScrollContainer
        • ViewportContainer
      • Création de conteneurs personnalisés
    • BBCode in RichTextLabel
      • Introduction
      • Using BBCode
      • Reference
        • Noms de couleurs prédéfinies
        • Codes de couleur héxadécimaux
        • Image vertical offset
      • Effets d’animation
        • Wave
        • Tornado
        • Shake
        • Fade
        • Rainbow
      • Custom BBCode tags and text effects
        • _process_custom_fx
        • Ghost
        • Pulse
        • Matrix
  • Fenêtre d’aperçu (Viewports)
    • Fenêtre d’aperçu (Viewports)
      • Introduction
      • Entrée
      • Listener
      • Cameras (2D & 3D)
      • Scale & stretching
      • Worlds
      • Capturer
      • Viewport Container
      • Rendu
      • Render target
    • Multiple resolutions
      • Le problème des résolutions multiples
      • One size fits all
      • Taille de base
      • Redimensionner
      • Parametre d’étirement
        • Mode Étirement
        • Stretch Aspect
        • Stretch Shrink
        • Depuis les scripts
        • Reducing aliasing on downsampling
        • Manipulation des rapports d’aspect
        • Field of view scaling
    • Utilisation d’un Viewport comme texture
      • Introduction
      • Configuration de la fenêtre d’affichage
      • Appliquer la texture
      • Créer la texture de la planète
      • Colorer la planète
      • Créer un océan
    • Post-traitement personnalisé
      • Introduction
      • Monopasse post-traitement
      • Post-traitement multi-passe
  • Ombres
    • Référence de shading
      • Shaders
        • Introduction
        • Types de shader
        • Mode de rendu
        • Fonctions processeur
      • Shading language
        • Introduction
        • Data types
        • Les tableaux
        • Constantes
        • Opérateurs
        • Contrôle de flux
        • Discarding
        • Fonctions
        • Fonctions intégrées
      • Shaders spatiaux
        • Mode de rendu
        • Sommets intégrés
        • Fragment intégrés
        • Lumière intégrée
      • CanvasItem shaders
        • Mode de rendu
        • Sommets intégrés
        • Fragment intégrés
        • Lumière intégrée
      • Shaders de particules
        • Mode de rendu
        • Sommets intégrés
    • Votre premier shader
      • Que sont les shaders ?
        • Introduction
        • But what are they?
        • Structure d’un shader
        • Aperçu technique
      • Votre premier shader de CanvasItem
        • Introduction
        • Configuration
        • Votre premier shader de CanvasItem
        • Votre première fonction fragment
        • Your first vertex function
        • Conclusion
      • Votre premier shader Spatial
        • Where to assign my material
        • Mise en place
        • Shader magic
        • Heightmap bruit
        • Uniforms
        • Interacting with light
      • Your first Spatial shader: part 2
        • Your first spatial fragment function
        • Animating with TIME
        • Advanced effects: waves
    • Shader materials
      • Introduction
      • Creating a ShaderMaterial
      • Converting to ShaderMaterial
    • VisualShaders
      • Creating a VisualShader
      • Using the Visual Shader Editor
      • Visual Shader nodes
        • Expression node
        • Fresnel node
        • Boolean node
        • If node
        • Switch node
    • Intro to shaders: 2D and 3D water
      • Tutoriels vidéo
      • Télécharger le code source
    • Screen-reading shaders
      • Introduction
      • SCREEN_TEXTURE built-in texture
      • SCREEN_TEXTURE example
      • Behind the scenes
      • Back-buffer logic
      • DEPTH_TEXTURE
    • Migrer vers le langage de shaders de Godot
      • Introduction
      • GLSL
        • Shader programs
        • Attributs des sommets
        • gl_Position
        • Varyings
        • Principal
        • Constantes
        • Macros
        • Variables
        • Coordinates
        • Precision
      • Shadertoy
        • Types
        • mainImage
        • Variables
        • Coordinates
      • The Book of Shaders
        • Types
        • Principal
        • Variables
        • Coordinates
    • Post-traitement avancé
      • Introduction
      • Quadrant plein écran
      • Texture de profondeur
      • Une optimisation
  • Réseau
    • High level multiplayer
      • High level vs low level API
      • Mid level abstraction
      • Initializing the network
      • Managing connections
      • RPC
      • Back to lobby
      • Starting the game
        • Player scenes
        • Synchronizing game start
      • Synchronizing the game
        • Network master
        • Mots-clés Master et puppet
    • Making HTTP requests
      • Preparing scene
      • Les scripts
      • Sending data to server
    • HTTP client class
    • SSL certificates
      • Introduction
      • Approach 1: self signed cert
      • Approach 2: CA cert
    • WebSocket
      • HTML5 and WebSocket
      • Utilisation de WebSocket dans Godot
        • Exemple de client minimal
        • Exemple de serveur minimal
        • Advanced chat demo
    • WebRTC
      • HTML5, WebSocket, WebRTC
        • WebSocket
        • WebRTC
      • Utilisation de WebRTC dans Godot
        • Minimal connection example
        • Exemple de signalisation locale
        • Remote signaling with WebSocket
  • Bibliothèque d’assets
    • About the Asset Library
      • Question fréquentes
        • Can paid assets be uploaded to the asset library?
    • Using the AssetLib
      • On the website
        • Vue d’ensemble
        • Searching
        • Breakdown of an asset
        • Registering and logging in
      • In the editor
    • Submitting to the Asset Library
      • Introduction
      • Submitting
      • Submission guidelines
  • Réalité virtuelle
    • AR/VR primer
      • AR/VR server
      • New AR/VR nodes
      • Other things to consider
    • VR Starer tutorial
      • VR Starter Tutorial Part One
        • Introduction
        • Tout préparer
        • Commencer en VR
        • Creating the controllers
        • Creating a base class for interactable VR objects
        • Reducing motion sickness
        • Notes finales
      • VR Starter Tutorial Part Two
        • Introduction
        • Adding destroyable targets
        • Ajouter un pistolet
        • Ajouter un fusil à pompe
        • Ajouter une bombe
        • Ajouter une épée
        • Mise à jour de l’UI cible
        • Adding the final special RigidBody
        • Notes finales
  • Extensions
    • Extensions pour l’éditeur
      • Création de plugins
        • A propos des plugins
        • Creating a plugin
        • A custom node
        • Going beyond
      • Création de plugins pour l’écran principal
        • Ce que couvre ce tutoriel
        • Initialisation du plugin
        • Les scènes
        • Scène de l’écran principal
        • Tabbed panel scene
        • Connecting the two scenes in the plugin script
        • Essayez le plugin
      • Import plugins
        • Introduction
        • Configuration
        • The EditorImportPlugin class
        • Options and presets
        • The import method
        • Platform variants and generated files
        • Trying the plugin
      • Gadget spatial plugins
        • Introduction
        • The EditorSpatialGizmoPlugin
        • Approche simple
        • Alternative approach
      • Plugins inspecteur
        • EditorInspectorPlugin
        • EditorProperty
      • Visual Shader plugins
    • GDNative
      • Exemple de GDNative en C
        • Introduction
        • Prérequis
        • Our C source
        • Compilation
        • Creating the GDNativeLibrary (.gdnlib) file
        • Creating the NativeScript (.gdns) file
      • Exemple GDNative C++
        • Introduction
        • Mise en place du projet
        • Building the C++ bindings
        • Créer un plugin simple
        • Compiler le plugin
        • Using the GDNative module
        • Ajouter des propriétés
        • Signaux
        • NativeScript 1.1 vs NativeScript 1.0
        • Next steps
    • Plugins Android
      • Création de plugins Android
        • Introduction
        • Maybe REST
        • plugin Android
        • Java singleton
        • Troubleshooting
        • Futur
  • Propre à une plateforme
    • Android in-app purchases
      • Getting the product details
      • Check if user purchased an item
      • Simple Purchase
      • Consumables and Non-Consumables
      • En période de test
    • Services pour iOS
      • Asynchronous methods
      • Store Kit
        • purchase
        • request_product_info
        • restore_purchases
      • Game Center
        • post_score
        • award_achievement
        • reset_achievements
        • request_achievements
        • request_achievement_descriptions
        • show_game_center
      • Multi-platform games
    • Personnalisation de la page HTML d’exportation Web
      • Substitution de caractères génériques
      • L’objet Engine
      • Démarrage d’une instance Engine
      • Configuration du comportement de démarrage
      • Personnalisation de la présentation
      • Accès au Module Emscripten en cours
    • Support des consoles dans Godot
      • Official support
      • Support de tierce partie
  • Le Multi-threading
    • Using multiple threads
      • Sujets
      • Création d’un thread
      • Mutexes
      • Semaphores
    • Thread safe APIs
      • Sujets
      • Portée globale
      • Arbre de scène
      • Tableaux GDScript, dictionnaires
      • Ressources
  • Création de contenu
    • Géométrie procédurale
      • Utilisation du ArrayMesh
        • ArrayMesh
        • Génération de la géométrie
        • Saving
      • Utilisation du MeshDataTool
      • Utilisation de SurfaceTool
      • Utilisation de ImmediateGeometry
      • Qu’est-ce que la géométrie ?
      • Qu’est-ce qu’un Mesh ?
      • Qu’est-ce qu’un Mesh est
        • Surfaces
        • Surface array
      • Outils
        • ArrayMesh
        • MeshDataTool
        • SurfaceTool
        • ImmediateGeometry
      • Lequel dois-je utiliser ?
    • Créer des arbres
      • Commencer avec un arbre
      • Peindre avec des couleurs de sommet
      • Write a custom shader for the leaves
      • Améliorer le shader
  • Optimisation
    • Optimization using Servers
      • Serveurs
      • RIDs
      • Création d’un sprite
      • Instantiating a Mesh into 3D space
      • Creating a 2D RigidBody and moving a sprite with it
      • Obtention des données depuis les serveurs
    • Optimization using MultiMeshes
      • MultiMeshes
      • Exemple Multimesh
  • Divers
    • Fixing jitter and stutter
      • What are jitter and stutter?
      • Distinguishing between them
      • Jitter
      • Stutter
        • Windows
        • Linux (X11)
        • macOS
        • Android
        • iOS
      • Reporting stutter or jitter problems
    • Handling quit requests
      • Quitting
      • Handling the notification
    • Pausing games
      • Pause?
      • How pausing works
      • White-listing nodes
      • Exemple
    • Binary serialization API
      • Introduction
      • Packet specification
        • 0: null
        • 1: bool
        • 2: int
        • 3: float/real
        • 4: String
        • 5: Vector2
        • 6: Rect2
        • 7: Vector3
        • 8: Transform2D
        • 9: Plane
        • 10: Quat
        • 11: AABB
        • 12: Basis
        • 13: Transform
        • 14: Color
        • 15: NodePath
        • 16: RID (unsupported)
        • 17: Object (unsupported)
        • 18: Dictionary
        • 19: Array
        • 20: PoolByteArray
        • 21: PoolIntArray
        • 22: PoolRealArray
        • 23: PoolStringArray
        • 24: PoolVector2Array
        • 25: PoolVector3Array
        • 26: PoolColorArray
    • Exécuter le code dans l’éditeur
      • What is tool?
      • Comment l’utiliser
      • Try it out
    • Changer de scène manuellement
    • Différences entre GLES2 et GLES3
      • Particules
      • SCREEN_TEXTURE mip-maps
      • DEPTH_TEXTURE
      • Espace de couleurs
      • HDR
      • Fonctionnalités SpatialMaterial
      • Fonctionnalités de l’environnement
      • GIProbes
      • Ombres de contact
      • Performance de la lumière
      • Compression de texture
      • Mélange de formes
      • Shading language
        • textureSize() workaround
      • Built in variables and render modes
    • Instanciation avec des signaux
      • Exemple de tir :
  • Débogage
    • Overview of debugging tools
      • Introduction
      • Debug dropdown options
        • Déployer avec le débogage distant
        • Déploiement minime avec système de fichier réseau
        • Formes de collision visibles
        • Navigation visible
        • Synchroniser les modifications des scènes
        • Synchroniser les modifications des scripts
      • Script editor debug tools and options
      • Paramètres de débogage du projet
        • Réglages
        • GDScript
        • Formes
      • Debugging tools
        • Débogueur
        • Erreurs
        • Profileur
        • Profileur réseau
        • Moniteurs
        • Mémoire vidéo
        • Divers
      • Remote in Scene dock
  • Légal
    • Respect des licences
      • Qu’est-ce que les licences ?
      • Pré-requis
      • inclusion
        • Credits screen
        • Écran des licences
        • Output log
        • Accompanying file
        • Manuel imprimé
      • Licences de tiers
        • Freetype
        • ENet
        • MBedTLS

Développement

  • Compilation
    • Getting the source
      • Downloading the Godot source code
    • Introduction to the buildsystem
      • SCons
      • Configuration
      • Platform selection
      • Resulting binary
      • Outils
      • Cible
      • Bits
      • Other build options
      • Exporter des modèles
    • Compiling for Windows
      • Pré-requis
      • Setting up SCons
      • Installing Visual Studio caveats
      • Downloading Godot’s source
      • Compilation
        • Sélection d’un compilateur
        • Running SCons
      • Development in Visual Studio or other IDEs
      • Cross-compiling for Windows from other operating systems
        • Troubleshooting
      • Creating Windows export templates
    • Compiling for X11 (Linux, *BSD)
      • Pré-requis
        • Distro-specific oneliners
      • Compilation
      • Building export templates
    • Compiler pour macOS
      • Pré-requis
      • Compilation
      • Compiling for 32 and 64-bit
      • Cross-compiling
    • Compiling for Android
      • Note
      • Pré-requis
      • Setting up the buildsystem
      • Building the export templates
        • Adding support for x86 devices
        • Nettoyage des modèles d’exportation générés
      • Using the export templates
        • Installing the templates
      • Troubleshooting
        • Application not installed
        • Application exits immediately
    • Compiling for iOS
      • Pré-requis
      • Compilation
      • Lancer
    • Cross-compiling for iOS on Linux
      • Disclaimer
      • Pré-requis
      • Configuring the environment
        • darling-dmg
        • Preparing the SDK
        • Toolchain
      • Compiling Godot for iPhone
        • Producing fat binaries
    • Compiling for Universal Windows Platform
      • Pré-requis
      • Compilation
      • Creating UWP export templates
      • Running UWP apps with Visual Studio
    • Compiling for the Web
      • Pré-requis
      • Building export templates
      • Building per asm.js translation or LLVM backend
    • Compiling with Mono
      • Pré-requis
      • Variables d’environnement
      • Enable the Mono module
      • Generate the glue
        • Notes
      • Rebuild with Mono glue
      • Exemples
        • Example (Windows)
        • Exemple (X11)
      • Data directory
        • Exporter des modèles
        • Éditeur
      • Cibler Android
      • Options de ligne de commande
    • Optimizing a build for size
      • Justification
      • Disabling 3D
      • Disabling advanced GUI nodes
      • Désactiver les modules non désirés
      • Optimizing for size instead of speed
      • Compiling with link-time optimization
      • Stripping binaries
      • Using UPX to compress binaries
    • Compiling with script encryption key
      • Pas à pas
      • Possible Errors
  • Développement du moteur
    • Introduction au développement de Godot
      • Diagramme d’architecture
      • Déboguer l’éditeur avec gdb
    • Configurer un EDI
      • Qt Creator
        • Importing the project
        • Build and run
        • Updating sources after pulling latest commits
        • Code style configuration
      • KDevelop
      • Xcode
        • Configuration du projet
        • Configuration du schéma
      • Visual Studio Code
      • Android Studio
        • Configuration du projet
    • Core types
      • Definitions
        • References:
      • Memory model
      • Allocating memory
        • References:
      • Containers
        • References:
      • Chaîne de caractères
        • References:
      • StringName
        • References:
      • Math types
        • References:
      • NodePath
        • References:
      • RID
        • References:
    • Variant class
      • À propos
        • References:
      • Containers: Dictionary and Array
        • References:
    • Object class
      • General definition
        • References:
      • Registering an Object
        • References:
      • Constantes
      • Properties (set/get)
      • Binding properties using _set/_get/_get_property_list
      • Dynamic casting
      • Signaux
      • References
        • References:
      • Ressources :
        • References:
      • Resource loading
        • References:
      • Resource saving
        • References:
    • Inheritance class tree
      • Object
      • Reference
      • Control
      • Node2D
      • Spatial
    • Modules personnalisées en C++
      • Modules
      • Pourquoi ?
      • Créer un nouveau module
      • Using the module
      • Improving the build system for development
      • Writing custom documentation
      • Ajout d’icônes d’éditeur personnalisé
      • Summing up
    • Liaison à des bibliothèques externes
      • Modules
      • Using the module
    • Chargeurs de format de ressources personnalisés
      • Introduction
        • References
      • Pourquoi ?
      • What not?
        • References
      • Creating a ResourceFormatLoader
      • Création de types de données personnalisés
        • Considerations
        • References
      • Enregistrement du nouveau format de fichier
        • References
      • Loading it on GDScript
    • Custom AudioStreams
      • Introduction
        • References:
      • Pourquoi ?
      • Create an AudioStream
        • References:
      • Create an AudioStreamPlayback
        • Resampling
        • References:
    • Serveurs Godot personnalisés
      • Introduction
        • References
      • Pourquoi ?
      • Créer un serveur Godot
      • Données de ressources gérées sur mesure
        • References
      • Enregistrement de la classe dans GDScript
        • Bind methods
      • MessageQueue
        • References:
      • Summing it up
        • Notes
  • Développement de l’éditeur
    • Introduction
    • Icônes de l’éditeur
      • Création d’icônes
      • Optimisation des icônes
      • Intégration et partage des icônes
      • Troubleshooting
      • References:
  • Formats de fichier
    • Le Format de Fichier TSCN
      • Structure de fichier
        • Entries inside the file
      • L’arbre de scène
        • NodePath
        • Squelette
        • BoneAttachment
        • AnimationPlayer
      • Ressources
        • External resources
        • Internal resources
        • ArrayMesh
        • Animation

Communauté

  • Contribuer
    • Ways to contribute
      • Contributing code
      • Testing and reporting issues
        • Testing development versions
        • Filing an issue on GitHub
      • Contributing to the documentation
    • Pull request workflow
      • Git source repository
      • Forking and cloning
      • Branching
      • Updating your branch
      • Making changes
      • Pushing changes to a remote
      • Issuing a pull request
      • Modifying a pull request
      • Mastering the PR workflow: the rebase
      • Deleting a Git branch
    • Code style guidelines
      • C++ and Objective-C
        • Using clang-format locally
        • Header includes
      • Java
      • Python
    • Bug triage guidelines
      • Issues management
        • Labels
        • Milestones
    • Documentation guidelines
      • How to contribute
      • The “Edit on GitHub” link
      • What makes good documentation?
      • Titles
      • Translating existing pages
      • Licence
    • Docs writing guidelines
      • 7 rules for a clear english
        • Use the direct voice
        • Use precise action verbs
        • Avoid verbs that end in -ing
        • Remove unnecessary adverbs and adjectives
        • Ban these 8 words
        • Use explicit references
        • Use “s to show possession
        • Use the Oxford comma to enumerate anything
      • How to write methods and classes
        • Give an overview of the node in the brief description
        • Mention what methods return if it’s useful
        • Use « if true » to describe booleans
        • Use [code] around arguments
      • Common vocabulary to use in godot’s docs
      • Image contribution guidelines
    • Contribuer à la référence des classes (API)
      • How to contribute
      • Débuter avec Github
        • Fork Godot
        • How to keep your local clone up-to-date
        • Mise à jour du modèle de documentation
        • Push and request a pull of your changes
      • Comment modifier la classe XML
        • Comment écrire la référence de classe
        • Améliorez le formatage avec les balises de style BBcode
        • Je ne sais pas ce que cette méthode fait !
        • Localisation
  • Canaux communautaires
    • Questions et réponses
    • IRC sur Freenode
    • Autres chats
    • Réseaux sociaux
    • Forum
  • Tutoriels et ressources
    • Par où commencer
    • Tutoriels vidéo
    • Tutoriels texte
    • Devlogs
    • Ressources
Godot Engine
  • Docs »
  • Interface graphique
  • View page source

Interface graphique¶

  • GUI skinning
  • Custom GUI controls
  • Size and anchors
  • Containers
  • BBCode in RichTextLabel
Next Previous

© Copyright 2014-2019, Juan Linietsky, Ariel Manzur and the Godot community (CC-BY 3.0) Revision 79929eda.

Built with Sphinx using a theme provided by Read the Docs.
Read the Docs v: latest
Versions
latest
Downloads
html
On Read the Docs
Project Home
Builds
Free document hosting provided by Read the Docs.