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
        • Réalité virtuelle
        • 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
        • 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
      • É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
      • Mise en place de la scène principale
      • 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 l’Interface Graphique de l’Utilisateur (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
      • Référence de ligne de commande
      • 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)
      • Exports GDScript
        • Introduction aux exports GDScript
        • Exemples
        • Exportation des indicateurs binaires
        • Exportation de tableaux
      • Guide de style GDScript
        • Formatage
        • Conventions de nommage
        • Ordre du code
        • 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
        • Profilage de votre code C#
        • Configuration de VS 2019 pour le débogage
      • Fonctionnalités
        • Conversion de type et Casting
        • Signaux C#
        • Preprocessor defines
      • 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
        • Formatage
        • Conventions de nommage
        • Variables locales implicitement typées
        • Autres considérations
    • Scripting multi-langage
      • Installer des nœuds
        • Instanciation des nœuds C# à partir de GDScript
        • Instanciation des nœuds GDScript à partir de C#
      • Accès aux champs
        • Accès aux champs C# depuis GDScript
        • Accéder au champ de GDscript depuis du C#
      • Méthodes d’appel
        • Appel de méthodes C# depuis GDScript
        • Appel de méthodes GDScript depuis C#
  • 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
        • Formats d’image pris en charge
        • 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
        • Fournir des icônes de lanceur
        • 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 efficaces
        • Choisir une arborescence de nœuds
      • Quand utiliser des scènes ou des scripts ?
        • Types anonymes
        • Types nommés
        • Conclusion
      • Chargements automatiques contre nœuds normaux
      • Le problème du son qui coupe
      • Gérer des données ou des fonctionnalités partagées
      • Quand utiliser un Chargement Automatique
      • 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
      • Sprite sheet with AnimatedSprite
      • Feuille de Sprite avec AnimationPlayer
        • Contrôle d’une animation AnimationPlayer
      • 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 des 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 d’assets
        • 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
        • Scène linéaire pour affichage référé non linéaire
      • 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
    • Enregistrement avec microphone
      • La structure de la démo
  • 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
        • Matrix components and the Identity matrix
        • Scaling the transformation matrix
        • Rotating the transformation matrix
        • Basis of the transformation matrix
        • Translating the transformation matrix
        • Putting it all together
        • Shearing the transformation matrix (advanced)
      • Practical applications of transforms
        • Converting positions between transforms
        • Moving an object relative to itself
        • Applying transforms onto transforms
        • Inverting a transformation matrix
      • How does it all work in 3D?
        • Representing rotation in 3D (advanced)
    • Interpolation
      • Interpolation vectorielle
      • Interpolation par transformation
      • Mouvement lisser
    • Béziers, courbes et chemins
      • Bézier quadratique
      • Bézier cubique
      • Ajout de points de contrôle
      • Curve2D, Curve3D, Path et Path2D
      • Évaluer
      • Dessin
      • Parcourir
  • Animation
    • Introduction aux fonctions de l’animation 2D
      • Vue d’ensemble
      • Créer un nœud AnimationPlayer
      • L’animation par ordinateur repose sur des clés d’animation
      • Tutoriel : Création d’une animation simple
        • Configuration de la scène
        • Ajout d’une piste
        • La deuxième clé d’animation
        • Lancer l’animation
        • Allers et retours
        • Paramètres de la piste
      • Clés d’animation pour d’autres propriétés
      • Modifier les clés d’animation
      • Avancé : Pistes de la méthode d’appel
    • Animation d’éléments découpés
      • Qu’est-ce que c’est ?
      • Animation cutout dans Godot
      • Fabrication de GBot
      • Mettre en place le rig
      • Ajustement du pivot
      • Nœud RemoteTransform2D
      • Compléter le squelette
      • Squelettes
      • Chaînes IK
      • Astuces d’animation
        • Définition des clés d’animation et exclusion des propriétés
      • Créer une position de repos
      • Modification de la rotation uniquement
      • Animer des chaînes IK
      • Déplacer visuellement un sprite derrière son parent
      • Réglage des courbes de transition pour plusieurs clés
      • Déformation squelettique 2D
    • 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
        • Machine à état
      • Racine de mouvement
      • Contrôle depuis le code
      • Voyage de la machine à état
  • Contrôles
    • InputEvent
      • Qu’est-ce que c’est ?
      • Comment ça marche ?
      • Anatomie d’un InputEvent
      • Actions
      • InputMap
    • Exemples d’entrée
      • Introduction
      • Événements comparés aux sondages
      • Événement d’entrée
      • InputMap
        • Capturer les actions
      • Événements clavier
        • Modificateurs de clavier
      • Événements souris
        • Boutons de la souris
        • Mouvement de la souris
      • Événements tactiles
    • Souris et coordonnées d’entrée
      • À propos
      • Coordonnées d’affichage matériel
      • Coordonnées d’affichage du viewport
    • Personnalisation du curseur de la souris
      • Utilisation des paramètres du projet
      • Utilisation d’un script
      • Projet de démonstration
      • Liste de curseurs
  • Entrée/Sortie
    • Chargement en arrière-plan
      • ResourceInteractiveLoader
      • Utilisation
        • Obtenir un ResourceInteractiveLoader
        • Interrogation
        • Progression du chargement (en option)
        • Forcer l’achèvement (facultatif)
        • Obtention de la ressource
      • Exemple
      • Utilisation de plusieurs threads
        • Utiliser un sémaphore
        • Ne pas bloquer le fil principal pendant l’interrogation
      • Exemple de classe
        • Exemple :
    • Chemins de données
      • Séparateurs de chemin
      • Chemin des ressources (Resource path)
      • Chemin utilisateur (données persistantes)
      • Chemins de données de l’éditeur
        • Mode autonome
    • L’enregistrement des parties
      • Introduction
      • Identifier des objets persistants
      • Sérialisation
      • Sauvegarde et lecture des données
      • Quelques notes
    • Cryptage des sauvegardes de jeu
      • Pourquoi ?
      • Comment ?
  • Internationalisation
    • Internationaliser des jeux
      • Introduction
      • Configuration de la traduction importée
      • Localisation des ressources
      • Conversion de clés en texte
      • Rendre les contrôles redimensionnables
      • TranslationServer
      • Ligne de commande
      • Traduire le nom du projet
    • Localisation à l’aide de gettext
      • Avantages
      • Désavantages
      • Mises en garde
      • Installation des outils gettext
      • Création manuelle du modèle PO (POT)
      • Création du modèle PO (POT) à l’aide de pybabel
      • Création d’un fichier de messages à partir d’un modèle PO
      • Chargement d’un fichier de messages dans Godot
      • Mise à jour des fichiers de messages pour suivre le modèle PO
      • Vérification de la validité d’un fichier ou d’un modèle PO
    • Versions de langues
  • Interface graphique
    • Personnalisation de GUI
      • Oh, magnifique GUI !
      • Thème
      • Options de thèmes
      • Personnalisation d’un contrôle
      • Création d’un thème
      • Exemple : thème d’un bouton
    • Controls GUI personnalisés
      • Tant de controls…
      • Dessin
        • Vérification de la taille du control
        • Vérification du focus
      • Dimensionnement
      • Entrée
        • Événement d’entrée
        • Notifications
    • Taille et ancrages
      • Centrage d’un contrôle
    • Conteneurs
      • Conteneurs de disposition
      • Drapeaux de taille
      • Types de conteneurs
        • Box Containers
        • Conteneur de grille
        • Conteneur de marge
        • Conteneur d’onglet
        • Split Container
        • PanelContainer
        • ScrollContainer
        • ViewportContainer
      • Création de conteneurs personnalisés
    • BBCode dans RichTextLabel
      • Introduction
      • Utilisation de BBCode
      • Référence
        • Noms de couleurs prédéfinies
        • Codes de couleur héxadécimaux
        • Décalage vertical de l’image
      • Effets d’animation
        • Vague
        • Tornade
        • Tremblement
        • Fondu
        • Arc-en-ciel
      • Balises BBCode et effets de texte personnalisés
        • _process_custom_fx
        • Fantôme
        • Pulsation
        • Matrice
  • Fenêtre d’aperçu (Viewports)
    • Fenêtre d’aperçu (Viewports)
      • Introduction
      • Entrée
      • Auditeur
      • Caméras (2D & 3D)
      • Échelle et étirement
      • Worlds
      • Capturer
      • Viewport Container
      • Rendu
      • Cible de rendu
    • Résolutions multiples
      • Le problème des résolutions multiples
      • Une taille qui convient pour tous
      • Taille de base
      • Redimensionner
      • Parametre d’étirement
        • Mode Étirement
        • Stretch Aspect
        • Stretch Shrink
        • Depuis les scripts
        • Réduction de l’aliasing lors du sous-échantillonnage
        • Manipulation des rapports d’aspect
        • Mise à l’échelle du champ de vision
    • 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
      • Langue de shading
        • Introduction
        • types
        • Les tableaux
        • Constantes
        • Structs
        • Opérateurs
        • Contrôle de flux
        • Jeter
        • Fonctions
        • Fonctions intégrées
      • Shaders spatiaux
        • Mode de rendu
        • Variables intégrées de sommet
        • Variables intégrées de fragment
        • Variables intégrées de lumière
      • CanvasItem shaders
        • Mode de rendu
        • Variables intégrées de sommet
        • Variables intégrées de fragment
        • Variables intégrées de lumière
      • Shaders de particules
        • Mode de rendu
        • Variables intégrées de sommet
    • Votre premier shader
      • Que sont les shaders ?
        • Introduction
        • Mais qu’est-ce que c’est ?
        • Structure d’un shader
        • Aperçu technique
      • Votre premier shader de CanvasItem
        • Introduction
        • Configuration
        • Votre premier shader de CanvasItem
        • Votre première fonction fragment
        • Votre première fonction vertex
        • Conclusion
      • Votre premier shader Spatial
        • Où assigner mon matériel
        • Mise en place
        • La magie des Shaders
        • Heightmap bruit
        • Uniforms
        • Interagir avec la lumière
      • Votre premier shader spatial : partie 2
        • Votre première fonction fragment spatial
        • Animation avec TIME
        • Effets avancés : les vagues
    • Shader materials
      • Introduction
      • Création d’un ShaderMaterial
      • Conversion en ShaderMaterial
    • VisualShaders
      • Création d’un VisualShader
      • Utilisation de l’éditeur Visual Shader
      • Nœuds Visual Shader
        • Nœud d’expression
        • Nœud Fresnel
        • Nœud booléen
        • Nœud if
        • Nœud switch
    • Introduction aux shaders : l’eau en 2D et 3D
      • Tutoriels vidéo
      • Télécharger le code source
    • Shaders de lecture d’écran
      • Introduction
      • SCREEN_TEXTURE texture intégrée
      • Exemple SCREEN_TEXTURE
      • Dans les coulisses
      • Logique du back-buffer
      • DEPTH_TEXTURE
    • Migrer vers le langage de shaders de Godot
      • Introduction
      • GLSL
        • Programmes de shader
        • Attributs des sommets
        • gl_Position
        • Varyings
        • Principal
        • Constantes
        • Macros
        • Variables
        • Coordonnées
        • Précision
      • Shadertoy
        • Types
        • mainImage
        • Variables
        • Coordonnées
      • Le Livre des Shaders
        • Types
        • Principal
        • Variables
        • Coordonnées
    • Post-traitement avancé
      • Introduction
      • Quadrant plein écran
      • Texture de profondeur
      • Une optimisation
  • Réseau
    • Multijoueur de haut niveau
      • API de haut niveau contre API de bas niveau
      • Abstraction de niveau moyen
      • Initialisation du réseau
      • Gestion des connexions
      • RPC
      • Retour au lobby
      • Démarrage du jeu
        • Scènes joueur
        • Synchroniser le démarrage de la partie
      • Synchronisation du jeu
        • Maître réseau
        • Mots-clés Master et puppet
    • Faire des requêtes HTTP
      • Préparer la scène
      • Les scripts
      • Envoi de données au serveur
    • Classe de client HTTP
    • Certificats SSL
      • Introduction
      • Approche 1 : certificat auto-signé
      • Approche 2 : certificat CA
    • WebSocket
      • HTML5 et WebSocket
      • Utilisation de WebSocket dans Godot
        • Exemple de client minimal
        • Exemple de serveur minimal
        • Démonstration de chat avancée
    • WebRTC
      • HTML5, WebSocket, WebRTC
        • WebSocket
        • WebRTC
      • Utilisation de WebRTC dans Godot
        • Exemple minimal de connexion
        • Exemple de signalisation locale
        • Signalisation à distance avec WebSocket
  • Bibliothèque d’assets
    • À propos de la bibliothèque d’Asset
      • Types of assets
      • Question fréquentes
        • Les assets payant peuvent-ils être téléchargés dans la bibliothèque d’asset ?
    • Utilisation de l’AssetLib
      • Sur le site
        • Vue d’ensemble
        • Recherche
        • Composition d’un asset
        • Inscription et connexion
      • Dans l’éditeur
    • Soumettre à la bibliothèque d’asset
      • Introduction
      • Directives de soumission
        • Pré-requis
        • Recommendations
      • Soumettre
  • Réalité virtuelle
    • Abécédaire AR/VR
      • Serveur AR/VR
      • Nouveaux nœuds AR/VR
      • Autres éléments à prendre en considération
    • Tutoriel pour commencer en VR
      • Tutoriel pour commencer en VR partie 1
        • Introduction
        • Tout préparer
        • Commencer en VR
        • Création des contrôleurs
        • Création d’une classe de base pour les objets VR interactifs
        • Réduire le mal des transports
        • Notes finales
      • Tutoriel pour commencer en VR partie 2
        • Introduction
        • Ajout de cibles destructibles
        • Ajouter un pistolet
        • Ajouter un fusil à pompe
        • Ajouter une bombe
        • Ajouter une épée
        • Mise à jour de l’UI cible
        • Ajout du dernier RigidBody spécial
        • Notes finales
  • Extensions
    • Extensions pour l’éditeur
      • Installing plugins
        • Finding plugins
        • Installing a plugin
        • Enabling a plugin
      • Création de plugins
        • A propos des plugins
        • Créer un plugin
        • Un nœud personnalisé
        • Aller plus loin
      • 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
        • Scène de panneau à onglets
        • Connecter les deux scènes dans le script du plugin
        • Essayez le plugin
      • Importer des plugins
        • Introduction
        • Configuration
        • La classe EditorImportPlugin
        • Options et préréglages
        • La méthode import
        • Variantes de plate-forme et fichiers générés
        • Essayer le plugin
      • Gadget spatial plugins
        • Introduction
        • L’EditorSpatialGizmoPlugin
        • Approche simple
        • Approche alternative
      • Plugins inspecteur
        • Configuration
        • EditorInspectorPlugin
        • EditorProperty
      • Visual Shader plugins
    • GDNative
      • Exemple de GDNative en C
        • Introduction
        • Prérequis
        • Nos sources en C
        • Compilation
        • Création du fichier GDNativeLibrary (.gdnlib)
        • Création du fichier NativeScript (.gdns)
      • Exemple GDNative C++
        • Introduction
        • Mise en place du projet
        • Construire(Building) des liaisons(bindings) C ++
        • Créer un plugin simple
        • Compiler le plugin
        • Utilisation du module GDNative
        • Ajouter des propriétés
        • Signaux
        • NativeScript 1.1 vs NativeScript 1.0
        • La suite
    • Plugins Android
      • Creating Android plugins (Godot 4.0+)
        • Introduction
        • plugin Android
        • Dépannage
  • Propre à une plateforme
    • Achats intégrés à l’application Android
      • Getting the product details
      • Check if user purchased an item
      • Simple Purchase
      • Consommables et non-consommables
      • En période de test
    • Services pour iOS
      • Méthodes asynchrones
      • 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
      • Support officiel
      • Support de tierce partie
  • Le Multi-threading
    • Utilisation de plusieurs 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
    • Optimisations en utilisant des 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
      • Que signifie tool ?
      • Comment l’utiliser
      • Testez-le
    • 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
      • Langue de shading
        • textureSize() workaround
      • Variables intégrées et modes de rendu
    • Instanciation avec des signaux
      • Exemple de tir :
    • State design pattern
      • Introduction
      • Script setup
      • Configuration du projet
  • Débogage
    • Overview of debugging tools
      • Options du menu de débogage
        • 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 au buildsystem
      • SCons
      • Configuration
      • Choix de la plate-forme
      • Binaire résultant
      • 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
        • Dépannage
      • Creating Windows export templates
    • Compiling for X11 (Linux, *BSD)
      • Pré-requis
        • Distro-specific one-liners
      • Compilation
      • Building export templates
      • Using Clang and LLD for faster development
    • Compiler pour macOS
      • Pré-requis
      • Compilation
      • Cross-compiling for macOS from Linux
    • 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
      • Dépannage
        • 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
      • CLion
    • Types cœur
      • Definitions
        • Références :
      • Modèle mémoire
      • Allouer de la mémoire
        • Références :
      • Conteneurs
        • Références :
      • Chaîne de caractères
        • Références :
      • StringName
        • Références :
      • Math types
        • Références :
      • NodePath
        • Références :
      • RID
        • Références :
    • La classe Variant
      • À propos
        • Références :
      • Containers: Dictionary and Array
        • Références :
    • Object class
      • General definition
        • Références :
      • Registering an Object
        • Références :
      • Constantes
      • Properties (set/get)
      • Binding properties using _set/_get/_get_property_list
      • Dynamic casting
      • Signaux
      • References
        • Références :
      • Ressources :
        • Références :
      • Chargement des ressources
        • Références :
      • Resource saving
        • Références :
    • Inheritance class tree
      • Object
      • Référence
      • Control
      • Node2D
      • Spatial
    • Modules personnalisées en C++
      • Modules
      • Pourquoi ?
      • Créer un nouveau module
      • Using the module
      • Customizing module types initialization
      • 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
      • Creating a ResourceFormatSaver
      • 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
        • Références :
      • Pourquoi ?
      • Create an AudioStream
        • Références :
      • Create an AudioStreamPlayback
        • Resampling
        • Références :
    • 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
        • Méthodes liées
      • MessageQueue
        • Références :
      • 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
      • Dépannage
      • Références :
  • 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
    • Best practices for engine contributors
      • Introduction
      • Langage
      • Best Practices
        • #1: The problem always comes first
        • #2: The problem has to exist
        • #3: The problem has to be complex or frequent
        • #4: The solution must be discussed with others
        • #5: To each problem, its own solution
        • #6: Cater to common use cases, leave the door open for the rare ones
        • #7: Solutions must be local
        • #8: Don’t use complex canned solutions for simple problems
    • Pull request workflow
      • Git source repository
      • Forker et cloner
      • Branching
      • Mettre à jour votre branche
      • Effectuer des modifications
      • Pousser les modifications sur un dépôt distant
      • Issuing a pull request
      • Modifier une pull request
      • Mastering the PR workflow: the rebase
      • Supprimer une branche Git
    • Lignes directrices pour le style du code
      • C++ et Objective-C
        • Utiliser clang-format localement
        • 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 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
        • Typage dynamique vs statique
        • Use real-world code examples where appropriate
        • 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 documentation
      • Keyboard shortcut guidelines
      • 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
    • Communautés linguistiques
    • Réseaux sociaux
    • Forum
  • Tutoriels et ressources
    • Par où commencer
    • Tutoriels vidéo
    • Tutoriels texte
    • Devlogs
    • Ressources
Godot Engine
  • Docs »
  • Contribuer
  • View page source

Contribuer¶

  • Ways to contribute
  • Best practices for engine contributors
  • Pull request workflow
  • Lignes directrices pour le style du code
  • Bug triage guidelines
  • Documentation guidelines
  • Docs writing guidelines
  • Contribuer à la référence des classes (API)
Next Previous

© Copyright 2014-2020, Juan Linietsky, Ariel Manzur and the Godot community (CC-BY 3.0) Revision 3547c4ff.

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.