Up to date

This page is up to date for Godot 4.2. If you still find outdated information, please open an issue.

Liste des fonctionnalités

Cette page vise à lister toutes les fonctionnalités actuellement supportées par Godot.

Note

This page lists features supported by the current stable version of Godot. Some of these features may not be available in the LTS release series (3.x).

Plates-formes

Peut exécuter à la fois l'éditeur et les projets exportés :

  • Windows 7 et versions ultérieures (64 bits et 32 bits).

  • macOS 10.12 et versions ultérieures (64-bit, x86 et ARM).

  • Linux (64-bit, x86 et ARM).

    • Les exécutables sont liés statiquement et peuvent fonctionner sur n'importe quelle distribution si compilés sur une distribution de base suffisamment ancienne.

    • Les exécutables officiels sont compilés sur Ubuntu 14.04.

    • Les exécutables 32 bits peuvent être compilés à partir des fichiers sources.

  • Android 6.0 et versions ultérieur (le support de l'éditeur est expérimental).

  • Navigateurs internet. Expérimental en 4.0, l'utilisation de Godot 3.x est recommandé à la place quand HTML 5 est visé.

Exécute les projets exportés :

  • iOS 11.0 et versions ultérieurs.

  • Consoles.

Godot vise à être aussi indépendant des plateformes que possible et peut être porté sur de nouvelles plateformes avec une relative facilité.

Note

Projects written in C# using Godot 4 currently cannot be exported to the web platform. To use C# on that platform, consider Godot 3 instead. Android and iOS platform support is available as of Godot 4.2, but is experimental and some limitations apply.

Éditeur

Fonctionnalités :

  • Éditeur de scène hiérarchique.

  • Éditeur de script intégré.

  • Support des éditeurs de script externes tels que Visual Studio Code ou Vim.

  • Débogueur GDScript.

    • Pas encore de support pour le débogage dans les flux d'exécution.

  • Profilateur visuel avec indications du temps CPU et GPU pour chaque étape du pipeline de rendu.

  • Outils de surveillance des performances, incluant des moniteurs de performances personnalisés.

  • Rechargement de script en direct.

  • Édition de scènes en direct.

    • Les changements seront répercutés dans l'éditeur et seront conservés après la fermeture du projet en cours.

  • Inspecteur à distance.

    • Les changements ne seront pas répercutés dans l'éditeur et ne seront pas conservés après la fermeture du projet en cours.

  • Réplication de caméra en direct.

    • Déplacez la caméra de l'éditeur et voyez le résultat dans le projet exécuté.

  • Documentation de référence de classe hors ligne intégrée.

  • Utilisez l'éditeur dans des dizaines de langues fournies par la communauté.

Plugins :

Rendu

3 méthodes de rendu (exécuté par dessus 2 pilotes de rendu) sont disponible :

  • Forward+, exécuté par dessus Vulkan 1.0 (avec optionnellement les fonctionnalités de Vulkan 1.1 et 1.2). Le backend graphique le plus avancé, adapté uniquement aux plateformes de bureau. Utilisé par défaut sur les plateformes de bureau.

  • Forward Mobile, exécuté par dessus Vulkan 1.0 (avec optionnellement les fonctionnalités de Vulkan 1.1 et 1.2). Moins de fonctionnalités, mais affiche les scènes simple plus rapidement. Adapté pour les plateformes mobiles et de bureau. Utilisé par défaut sur les plateformes mobiles.

  • Compatibilité, exécuté par dessus OpenGL 3.3 / OpenGL ES 3.0 / WebGL 2.0. Le backend graphique le moins avancé, adapté aux plateformes de bureau bas de gamme et aux plateformes mobiles. Utilisé par défaut sur la plateforme web.

Graphismes 2D

  • Rendu de sprite, polygone et ligne.

    • Des outils de haut niveau pour dessiner des lignes et des polygones tels que Polygon2D et Line2D, avec un support pour la texturisation.

  • AnimatedSprite2D comme un assistant à la création de sprites animés.

  • Couches de parallaxe.

    • Pseudo-3D supportée incluant un aperçu dans l'éditeur.

  • éclairage 2D avec une carte normale et une carte spéculaire.

    • Lumières ponctuelles (omnidirectionnelles/spot) et directionnelles 2D.

    • Ombres dur ou douce (ajustement individuel de chaque lumières).

    • Les shaders customisés peuvent accéder en temps réel a une représentation SDF (Champs de Distance Signée)`de la scène 2D basé sur les nœuds :ref:`class_LightOccluder2D, qui peuvent être utilisé pour améliorer les effets de lumières 2D et les effets 2D d'illumination global.

  • Rendu de police utilisant des bitmaps, la rasterisation avec FreeType ou des champs de distances signées multicanal (MSDF).

    • Les polices bitmap peuvent être exportées à l'aide d'outils comme BMFont, ou importé d'images (pour des polices avec une largeur fixée seulement).

    • DynamicFont prend en charge les polices monochromes ainsi que les polices colorées (par exemple les emojis). Les formats pris en charge sont TTF, OTF, WOFF1 et WOFF2.

    • Le support des polices dynamiques propose des contours de police facultatifs avec une largeur et une couleur ajustables.

    • Les polices dynamiques supportent les polices variables et les fonctionnalités d'OpenType ainsi que les ligatures.

    • Les polices Dynamiques supportent le gras et l'italique simulé quand le fichier de la police n'a pas ces styles.

    • Prise en charge du sur-échantillonnage des polices pour maintenir la netteté des polices à des résolutions plus élevées.

    • Les polices dynamiques prennent en charge le positionnement subpixel pour rendre les polices plus nettes à de petites tailles.

    • Les polices dynamique supportent les optimisations LCD subpixel pour rendre les polices encore plus nettes à des petites tailles.

    • Les polices de caractères de cartes de distances signés peuvent être changés dans n'importe quelle résolution sans passer par une Rastérisation. L'usage multi-canaux permet aux polices de caractères SDF d'être réduites à de plus petites tailles comparés à des polices SDF monochromes.

  • GPU-based particles with support for custom particle shaders.

  • Particules générées par le CPU.

  • Optional 2D HDR rendering for better glow capabilities.

Outils 2D

  • TileMaps pour du level design 2D basé sur des tuiles.

  • Caméra 2D avec lissage intégré et marges de glissement.

  • Nœud Path2D pour représenter un chemin dans l'espace 2D.

    • Peut être dessiné dans l'éditeur ou généré de manière procédurale.

    • PathFollow2D pour que les nœuds suivent un Path2D.

  • 2D geometry helper class.

Physique 2D

Corps physiques :

  • Corps statiques.

  • Corps à animer (pour des objets bougeant uniquement par script ou animation, comme des portes et des plateformes).

  • Corps rigides.

  • Character bodies.

  • Les articulations.

  • Areas pour détecter les corps qui y entrent ou en sortent.

Détection de collision :

  • Built-in shapes: line, box, circle, capsule, world boundary (infinite plane).

  • Polygones de collision (peuvent être dessinés manuellement ou générés à partir d'un sprite dans l'éditeur).

Graphiques 3D

  • HDR rendering with sRGB.

  • Caméras perspective, orthographiques et frustum-offset.

  • When using the Forward+ backend, a depth prepass is used to improve performance in complex scenes by reducing the cost of overdraw.

  • Variable rate shading on supported GPUs in Forward+ and Forward Mobile.

Rendu basé sur la physique (fonctionnalités de matériau intégrés):

  • Suit le modèle Disney PBR.

  • Supports Burley, Lambert, Lambert Wrap (half-Lambert) and Toon diffuse shading modes.

  • Supports Schlick-GGX, Toon and Disabled specular shading modes.

  • Utilise un flux de travail de type rugosité-métal avec support des textures ORM.

  • Uses horizon specular occlusion (Filament model) to improve material appearance.

  • Normal mapping.

  • Parallax/relief mapping with automatic level of detail based on distance.

  • Mapping de détail pour l'albedo et les normal maps.

  • Sub-surface scattering and transmittance.

  • Screen-space refraction with support for material roughness (resulting in blurry refraction).

  • Proximity fade (soft particles) and distance fade.

  • Distance fade can use alpha blending or dithering to avoid going through the transparent pipeline.

  • Le Dithering peut être déterminée par pixel ou par objet.

Éclairage en temps réel :

  • Lumières directionnelles (soleil/lune). Jusqu'à 4 par scène.

  • Lumières omnidirectionnelles.

  • Lumières spot avec angle de cône et atténuation réglables.

  • Specular, indirect light, and volumetric fog energy can be adjusted on a per-light basis.

  • Adjustable light "size" for fake area lights (will also make shadows blurrier).

  • Optional distance fade system to fade distant lights and their shadows, improving performance.

  • When using the Forward+ backend (default on desktop), lights are rendered with clustered forward optimizations to decrease their individual cost. Clustered rendering also lifts any limits on the number of lights that can be used on a mesh.

  • When using the Forward Mobile backend, up to 8 omni lights and 8 spot lights can be displayed per mesh resource. Baked lighting can be used to overcome this limit if needed.

Shadow mapping :

  • DirectionalLight : Orthogonal (fastest), PSSM 2-split and 4-split. Supporte le mélange entre les divisions (splits).

  • OmniLight : Double paraboloïde (rapide) ou cubemap (plus lent mais plus précis). Supporte les textures colorées du projecteur sous forme de panoramas.

  • SpotLight: Single texture. Supports colored projector textures.

  • Shadow normal offset bias and shadow pancaking to decrease the amount of visible shadow acne and peter-panning.

  • PCSS-like shadow blur based on the light size and distance from the surface the shadow is cast on.

  • Adjustable shadow blur on a per-light basis.

Éclairage global avec éclairage indirect :

  • Baked lightmaps (fast, but can't be updated at run-time).

    • Supporte le pré-calcul de l'éclairage indirect seul ou le pré-calcul de l'éclairage direct et indirect. Le mode de pré-calcul peut être ajusté pour chaque lumière afin de permettre le pré-calcul de configurations d'éclairages hybrides.

    • Supports lighting dynamic objects using automatic and manually placed probes.

    • Optionally supports directional lighting and rough reflections based on spherical harmonics.

    • Lightmaps are baked on the GPU using compute shaders (much faster compared to CPU lightmapping). Baking can only be performed from the editor, not in exported projects.

    • Supports GPU-based denoising with JNLM, or CPU/GPU-based denoising with OIDN.

  • Voxel-based GI probes. Supports dynamic lights and dynamic occluders, while also supporting reflections. Requires a fast baking step which can be performed in the editor or at run-time (including from an exported project).

  • Signed-distance field GI designed for large open worlds. Supports dynamic lights, but not dynamic occluders. Supports reflections. No baking required.

  • Screen-space indirect lighting (SSIL) at half or full resolution. Fully real-time and supports any kind of emissive light source (including decals).

  • VoxelGI and SDFGI use a deferred pass to allow for rendering GI at half resolution to improve performance (while still having functional MSAA support).

Réflexions :

  • Voxel-based reflections (when using GI probes) and SDF-based reflections (when using signed distance field GI). Voxel-based reflections are visible on transparent surfaces, while rough SDF-based reflections are visible on transparent surfaces.

  • Réflexions rapides précalculées ou lentes en temps réel à l'aide de ReflectionProbe. La correction de la parallaxe peut être activée en option.

  • Screen-space reflections with support for material roughness.

  • Les techniques de réflexion peuvent être mélangées pour une plus grande précision ou une plus grande évolutivité.

  • When using the Forward+ backend (default on desktop), reflection probes are rendered with clustered forward optimizations to decrease their individual cost. Clustered rendering also lifts any limits on the number of reflection probes that can be used on a mesh.

  • When using the Forward Mobile backend, up to 8 reflection probes can be displayed per mesh resource.

Decals:

  • Supports albedo, emissive, ORM, and normal mapping.

  • Texture channels are smoothly overlaid on top of the underlying material, with support for normal/ORM-only decals.

  • Support for normal fade to fade the decal depending on its incidence angle.

  • Does not rely on run-time mesh generation. This means decals can be used on complex skinned meshes with no performance penalty, even if the decal moves every frame.

  • Support for nearest, bilinear, trilinear or anisotropic texture filtering (configured globally).

  • Optional distance fade system to fade distant lights and their shadows, improving performance.

  • When using the Forward+ backend (default on desktop), decals are rendered with clustered forward optimizations to decrease their individual cost. Clustered rendering also lifts any limits on the number of decals that can be used on a mesh.

  • When using the Forward Mobile backend, up to 8 decals can be displayed per mesh resource.

Ciel :

  • Ciel panoramique (en utilisant un HDRI).

  • Procedural sky and Physically-based sky that respond to the DirectionalLights in the scene.

  • Support for custom sky shaders, which can be animated.

  • The radiance map used for ambient and specular light can be updated in real-time depending on the quality settings chosen.

Brouillard :

  • Profondeur de brouillard exponentielle.

  • Exponential height fog.

  • Support for automatic fog color depending on the sky color (aerial perspective).

  • Support for sun scattering in the fog.

  • Support pour contrôler à quel point le rendu du brouillard doit affecter le ciel, avec des contrôles séparés pour le brouillard traditionnel et volumétrique.

  • Support for making specific materials ignore fog.

Brouillard volumétrique :

  • Global volumetric fog that reacts to lights and shadows.

  • Volumetric fog can take indirect light into account when using VoxelGI or SDFGI.

  • Fog volume nodes that can be placed to add fog to specific areas (or remove fog from specific areas). Supported shapes include box, ellipse, cone, cylinder, and 3D texture-based density maps.

  • Chaque volume de brouillard peut avoir son propre shader personnalisé.

  • Peut être utilisé avec un brouillard traditionnel.

Particules :

  • GPU-based particles with support for subemitters (2D + 3D), trails (2D + 3D), attractors (3D only) and collision (2D + 3D).

    • 3D particle attractor shapes supported: box, sphere and 3D vector fields.

    • 3D particle collision shapes supported: box, sphere, baked signed distance field and real-time heightmap (suited for open world weather effects).

    • 2D particle collision is handled using a signed distance field generated in real-time based on LightOccluder2D nodes in the scene.

    • Trails can use the built-in ribbon trail and tube trail meshes, or custom meshes with skeletons.

    • Support for custom particle shaders with manual emission.

  • Particules générées par le CPU.

Post-traitement :

  • Tonemapping (Linear, Reinhard, Filmic, ACES).

  • Automatic exposure adjustments based on viewport brightness (and manual exposure override).

  • Near and far depth of field with adjustable bokeh simulation (box, hexagon, circle).

  • Screen-space ambient occlusion (SSAO) at half or full resolution.

  • Glow/bloom with optional bicubic upscaling and several blend modes available: Screen, Soft Light, Add, Replace, Mix.

  • Glow can have a colored dirt map texture, acting as a lens dirt effect.

  • Glow can be used as a screen-space blur effect.

  • Color correction using a one-dimensional ramp or a 3D LUT texture.

  • Roughness limiter to reduce the impact of specular aliasing.

  • Réglages de la luminosité, du contraste et de la saturation.

Filtrage de texture :

  • Filtrage nearest, bilinear, trilinear ou anisotropic.

  • Filtering options are defined on a per-use basis, not a per-texture basis.

Compression de texture :

  • Basis Universal (slow, but results in smaller files).

  • BPTC for high-quality compression (not supported on macOS).

  • ETC2 (not supported on macOS).

  • S3TC (not supported on mobile/Web platforms).

Anticrénelage :

  • Temporal antialiasing (TAA).

  • AMD FidelityFX Super Resolution 2.2 antialiasing (FSR2), which can be used at native resolution as a form of high-quality temporal antialiasing.

  • Multi-sample antialiasing (MSAA), for both 2D antialiasing and 3D antialiasing.

  • Anticrénelage approximatif rapide (FXAA).

  • Super-sample antialiasing (SSAA) using bilinear 3D scaling and a 3D resolution scale above 1.0.

  • Alpha antialiasing, MSAA alpha to coverage and alpha hashing on a per-material basis.

Resolution scaling:

  • Support for rendering 3D at a lower resolution while keeping 2D rendering at the original scale. This can be used to improve performance on low-end systems or improve visuals on high-end systems.

  • Resolution scaling uses bilinear filtering, AMD FidelityFX Super Resolution 1.0 (FSR1) or AMD FidelityFX Super Resolution 2.2 (FSR2).

  • Texture mipmap LOD bias is adjusted automatically to improve quality at lower resolution scales. It can also be modified with a manual offset.

Most effects listed above can be adjusted for better performance or to further improve quality. This can be helpful when using Godot for offline rendering.

Outils 3D

  • Built-in meshes: cube, cylinder/cone, (hemi)sphere, prism, plane, quad, torus, ribbon, tube.

  • GridMaps for 3D tile-based level design.

  • Constructive solid geometry (destiné au prototypage).

  • Outils pour génération de la géométrie procédurale.

  • Nœud Path3D pour représenter un chemin dans l'espace 3D.

    • Peut être dessiné dans l'éditeur ou généré de manière procédurale.

    • PathFollow3D pour que les nœuds suivent un Path3D.

  • 3D geometry helper class.

  • Support for exporting the current scene as a glTF 2.0 file, both from the editor and at run-time from an exported project.

Physique 3D

Corps physiques :

  • Corps statiques.

  • Corps à animer (pour des objets bougeant uniquement par script ou animation, comme des portes et des plateformes).

  • Corps rigides.

  • Character bodies.

  • Corps de véhicules (destinées à la physique arcade, pas à la simulation).

  • Les articulations.

  • Corps mous.

  • Ragdolls.

  • Areas pour détecter les corps qui y entrent ou en sortent.

Détection de collision :

  • Built-in shapes: cuboid, sphere, capsule, cylinder, world boundary (infinite plane).

  • Générer des formes de collision triangle pour n'importe quel maillage à partir de l'éditeur.

  • Générer une ou plusieurs formes de collision convexes pour n'importe quel maillage à partir de l'éditeur.

Shaders

  • 2D : Vertex, fragment et shaders de lumière personnalisés.

  • 3D : Vertex, fragment, lumière et shaders de ciel personnalisés.

  • Shaders basés sur du texte utilisant un langage de shader inspiré de GLSL <doc_shading_language>.

  • Éditeur de shaders visuels.

    • Prise en charge des plugins de shaders visuels.

Les scripts

Général :

  • Modèle de conception orientée-objet avec des scripts étendant(extend) de nœuds.

  • Signaux et groupes pour la communication entre les scripts.

  • Prise en charge de script cross-langage.

  • Many 2D, 3D and 4D linear algebra data types such as vectors and transforms.

GDScript :

C# :

  • Emballé dans un binaire séparé pour limiter la taille des fichiers et les dépendances.

  • Supports .NET 6 and higher.

    • Full support for the C# 10.0 syntax and features.

  • Supports Windows, Linux, and macOS. As of 4.2 experimental support for Android and iOS is also available (requires a .NET 7.0 project for Android and 8.0 for iOS).

    • On the Android platform only some architectures are supported: arm64 and x64.

    • On the iOS platform only some architectures are supported: arm64.

    • The web platform is currently unsupported. To use C# on that platform, consider Godot 3 instead.

  • Il est recommandé d'utiliser un éditeur externe pour bénéficier des fonctionnalités d'un IDE.

GDExtension (C, C++, Rust, D, ...):

  • Lorsque vous en avez besoin, créez un lien vers des bibliothèques natives pour des performances plus élevées et des intégrations tierces.

    • Pour les scripts de logique de jeu, GDScript ou C # sont recommandés si leurs performances sont appropriées.

  • Official GDExtension bindings for C and C++.

    • Utilisez le système de compilation et les fonctionnalités de langage que vous souhaitez.

  • Actively developed GDExtension bindings for D, Haxe, Swift, and Rust bindings provided by the community. (Some of these bindings may be experimental and not production-ready).

Audio

Fonctionnalités :

  • Mono, stéréo, sortie 5.1 et 7.1.

  • Lecture(playback) non positionnelle et positionnelle en 2D et 3D.

    • Effet Doppler optionnel en 2D et 3D.

  • Support d' audio bus re-routable et des effets avec des dizaines d'effets inclus.

  • Support for polyphony (playing several sounds from a single AudioStreamPlayer node).

  • Support for random volume and pitch.

  • Support for real-time pitch scaling.

  • Support for sequential/random sample selection, including repetition prevention when using random sample selection.

  • Les nœuds Listener2D et Listener3D pour écouter depuis une position différente de celle de la caméra.

  • Support for procedural audio generation.

  • Audio input to record microphones.

  • Entrée MIDI.

    • Pas encore de support pour la sortie MIDI.

API utilisés :

  • Windows : WASAPI.

  • macOS : CoreAudio.

  • Linux : PulseAudio ou ALSA.

Importer

Formats :

  • Images: See Importer des images.

  • Audio :

    • WAV avec compression IMA-ADPCM optionnelle.

    • Ogg Vorbis.

    • MP3.

  • 3D scenes: See Importation de scènes 3D.

    • glTF 2.0 (recommandé).

    • .blend (by calling Blender's glTF export functionality transparently).

    • FBX (by calling FBX2glTF transparently).

    • Collada (.dae).

    • Wavefront OBJ (static scenes only, can be loaded directly as a mesh or imported as a 3D scene).

  • Support for loading glTF 2.0 scenes at run-time, including from an exported project.

  • Les maillages 3D utilisent Mikktspace pour générer les tangentes à l'importation, ce qui permet de s'assurer de la cohérence avec les autres applications 3D comme Blender.

Entrée

  • Input mapping system using hardcoded input events or remappable input actions.

    • Les valeurs des axes peuvent être associées à deux actions différentes avec une zone morte configurable.

    • Utilise le même code pour prendre en charge les claviers et les gamepads.

  • Entrée clavier.

    • Les touches peuvent être mappées en mode "physique" pour être indépendantes de la disposition du clavier.

  • Entrée souris.

    • Le curseur de la souris peut être visible, caché, capturé ou confiné dans la fenêtre.

    • Lorsque capturées, les données brutes seront utilisées sous Windows et Linux pour contourner les paramètres d'accélération de la souris du système d'exploitation.

  • Entrée manette (jusqu'à 8 contrôleurs en simultané).

  • Saisie au stylet/tablette avec support de la pression.

Réseau

  • Low-level TCP networking using StreamPeer and TCPServer.

  • Low-level UDP networking using PacketPeer and UDPServer.

  • Low-level HTTP requests using HTTPClient.

  • High-level HTTP requests using HTTPRequest.

    • Support HTTPS utilisant des certificats groupés.

  • High-level multiplayer API using UDP and ENet.

    • Réplication automatique au moyen de remote procedure calls (RPC).

    • Support des transferts peu fiables, sûrs et ordonnés (unreliable, reliable and ordered).

  • WebSocket client and server, available on all platforms.

  • WebRTC client and server, available on all platforms.

  • Support for UPnP to sidestep the requirement to forward ports when hosting a server behind a NAT.

Internationalisation

  • Support complet d'Unicode, y compris les emojis.

  • Enregistrez les chaînes de caractères de localisation en utilisant CSV ou gettext.

    • Support for generating gettext POT and PO files from the editor.

  • Utilisez les chaînes de caractère localisées dans votre projet automatiquement dans les éléments de l'interface graphique ou en utilisant la fonction tr().

  • Support for pluralization and translation contexts when using gettext translations.

  • Support for bidirectional typesetting, text shaping and OpenType localized forms.

  • Automatic UI mirroring for right-to-left locales.

  • Support for pseudolocalization to test your project for i18n-friendliness.

Fenêtrage et intégration au systèmes d'exploitation

  • Spawn multiple independent windows within a single process.

  • Move, resize, minimize, and maximize windows spawned by the project.

  • Changez le titre et l'icône de la fenêtre.

  • Demander l'attention (fera clignoter la barre de titre sur la plupart des plateformes).

  • Mode plein écran.

    • Uses borderless fullscreen by default on Windows for fast alt-tabbing, but can optionally use exclusive fullscreen to reduce input lag.

  • Borderless windows (fullscreen or non-fullscreen).

  • Ability to keep a window always on top.

  • Intégration au menu global sur macOS.

  • Execute commands in a blocking or non-blocking manner (including running multiple instances of the same project).

  • Ouvrez les chemins d'accès aux fichiers et les URL en utilisant les gestionnaires de protocole par défaut ou personnalisés (s'ils sont enregistrés dans le système).

  • Analyser les arguments de ligne de commande personnalisés.

  • Any Godot binary (editor or exported project) can be used as a headless server by starting it with the --headless command line argument. This allows running the engine without a GPU or display server.

Mobile

  • In-app purchases on Android and iOS.

  • Support des annonces publicitaires en utilisant des modules tiers.

Support XR (AR et VR)

  • Out of the box support for OpenXR.

    • Including support for popular desktop headsets like the Valve Index, WMR headsets, and Quest over Link.

  • Support for Android based headsets using OpenXR through a plugin.

    • Including support for popular stand alone headsets like the Meta Quest 1/2/3 and Pro, Pico 4, Magic Leap 2, and Lynx R1.

  • Other devices supported through an XR plugin structure.

  • Various advanced toolkits are available that implement common features required by XR applications.

GUI système

L'interface graphique de Godot est construite en utilisant les mêmes nœuds Control que ceux utilisés pour les jeux dans Godot. L'interface utilisateur de l'éditeur peut facilement être étendue de nombreuses façons à l'aide d'add-ons.

Nodes :

  • Buttons (Boutons).

  • Cases à cocher, boutons à cocher, boutons radio.

  • Text entry using LineEdit (single line) and TextEdit (multiple lines). TextEdit also supports code editing features such as displaying line numbers and syntax highlighting.

  • Dropdown menus using PopupMenu and OptionButton.

  • Barres de défilement.

  • Étiquettes (Lables).

  • RichTextLabel for text formatted using BBCode, with support for animated custom effects.

  • Trees (arbres) (peuvent également être utilisés pour représenter des tableaux).

  • Un sélectionneur de couleur avec les modes RGB et HSV.

  • Controls peuvent être tournés et mis à l'échelle.

Dimensionnement :

  • Des ancres pour maintenir les éléments de l'interface graphique dans un coin spécifique, un bord ou au centre.

  • Conteneurs pour placer automatiquement les éléments de l'interface graphique en suivant certaines règles.

  • Scale to multiple resolutions using the canvas_items or viewport stretch modes.

  • Support de tout les rapports d'aspect en utilisant des ancres et l'aspect d'étirement expand.

Theming :

  • Éditeur de thèmes intégré.

    • Générer un thème basé sur les paramètres actuels du thème de l'éditeur.

  • Thème vectoriel procédural utilisant StyleBoxFlat.

    • Supporte les coins arrondis/biseautés, les ombres portées, et les largeurs par bordure et l'anticrénelage.

  • Thème basée sur une texture en utilisant StyleBoxTexture.

La petite taille de distribution de Godot peut en faire une alternative appropriée à des frameworks comme Electron ou Qt.

Animation

  • Direct kinematics et inverse kinematics.

  • Support de l'animation de toute propriété avec par interpolation personnalisable.

  • Support des méthodes d'appel dans les pistes d'animation.

  • Support de la lecture de sons dans les pistes d'animation.

  • Support des courbes de Bézier dans les animations.

Formats de fichier

  • Les scènes et les ressources peuvent être enregistrées dans text-based ou des formats binaire.

    • Les formats en texte sont lisibles par l'homme et plus compatible avec le contrôle de version.

    • Les formats binaires sont plus rapides à sauvegarder/charger pour les grandes scènes/ressources.

  • Read and write text or binary files using FileAccess.

    • Peut éventuellement être compressé ou chiffré.

  • Lecture et écriture de fichiers JSON.

  • Lecture et écriture de fichiers de configuration de type INI en utilisant ConfigFile.

    • Peut (dé)sérialiser tous les types de données Godot, comme Vector2/3, Color, ...

  • Lire les fichiers XML en utilisant XMLParser.

  • Load and save images, audio/video, fonts and ZIP archives in an exported project without having to go through Godot's import system.

  • Emballez les données de jeu dans un fichier PCK (format custom optimisé pour la recherche rapide), dans une archive ZIP ou directement dans l'exécutable pour une distribution en fichier unique.

  • Exporter des fichiers PCK supplémentaires qui peuvent être lus par le moteur pour supporter les mods et les DLCs.

Divers

  • Video playback with built-in support for Ogg Theora.

  • Movie Maker mode to record videos from a running project with synchronized audio and perfect frame pacing.

  • Accès de bas niveau aux serveurs ce qui permet de contourner la surcharge de l'arbre de scène lorsque cela est nécessaire.

  • Command line tutorial pour l'automatisation.

    • Exporter et déployer des projets en utilisant des plateformes d'intégration continue.

    • Des scripts de complétion sont disponibles pour Bash, zsh et fish.

    • Print colored text to standard output on all platforms using print_rich.

  • Support for C++ modules statically linked into the engine binary.

  • Engine and editor written in C++17.

    • Peut être compilé en utilisant GCC, Clang and MSVC. MinGW est également pris en charge.

    • Respectueux des packagers. Dans la plupart des cas, les bibliothèques système peuvent être utilisées à la place de celles fournies par Godot. Le système de compilation ne télécharge rien. Les compilations peuvent être entièrement reproductibles.

  • Licencié sous la licence permissive MIT.

Voir aussi

Le répertoire de propositions Godot liste les fonctionnalités qui ont été demandées par la communauté et qui pourraient être implémentées dans les futures versions de Godot.