Lista das funcionalidades

Esta página visa listar todos os recursos atualmente suportados pelo Godot.

Nota

Essa pagina lista as funcionalidades da atual versão estável do Godot (3.2) Mais funcionalidades estão disponíveis na versão mais recente(4.0).

Funcionalidades

Plataformas

Pode rodar tanto o editor quanto os projetos exportados:

  • Windows 7 e superior (64-bit e 32-bit).

  • macOS 10.12 e superior (64-bit, x86 e ARM).

  • Linux (64-bits e 32-bits, x86 e ARM).

    • Aquivos binarios são estatisticamente vinculados e poderam ser executados em qualquer distribuição se compilados apartir de uma distribuição base mais antiga.
    • Binários oficiais são compilados em Ubuntu 14.04.

Execute projetos exportados:

  • Android 4.4 e superior.
  • iOS 10.0 e superior.
  • HTML5 via WebAssembly (Firefox, Chrome, Edge, Opera).
  • Consoles.

Godot visa ser o mais independente de plataforma possível e pode ser portado para novas plataformas com relativa facilidade.

Editor

Funcionalidades:

  • Árvore editora de cena.

  • Editor de Script.

  • Suporte a external script editors como Visual Studio Code ou Vim.

  • GDScript debugger.

    • Por enquanto, sem suporte para debugging em threads.
  • Ferramentas de monitoramento de performance.

  • Carregando cenas.

  • Edição de cena em tempo real.

    • Alterações serão refletidas no editor e se manteram mesmo após fechar o projeto em execução.
  • Inspetor remoto.

    • Alterações não serão refletidas no editor e não se mantidas após fechar o projeto em execução.
  • Replicação de câmera em tempo real.

    • Mova a câmera do editor e verá os resultados no projeto em execução.
  • Utilize o editor em dezenas de idiomas fornecidos pela própria comunidade.

Plugins:

  • Plugins para o editor podem ser baixados através da Biblioteca de recursos, permitindo a expansão das funcionalidades do editor.
  • Crie seus próprios plugins utilizando GDScript para adicionar novas funcionalidades ou para acelerar o seu trabalho.
  • Baixe projetos a partir da Biblioteca de recursos e importe-os diretamente.

Gráficos 2D

Dois tipos de renderizadores disponíveis:

  • Renderizador OpenGL ES 3.0 (Utilize OpenGL ES 3.3 em plataformas desktop).
    • Visuais de alta nível. Recomendado para plataformas desktop.
  • Renderizador OpenGL ES 2.0 (utilize OpenGL ES 2.1 em plataformas desktop).
    • Recomendado para plataformas Web e dispositivos móveis.

Funcionalidades:

  • Sprite, polignos e renderizador de linhas.

    • Ferramentas de alto-nível para desenhar linhas e polígnos tal como Line2D e Polygon2D.
  • AnimatedSprite irá ajudar na criação de sprites animados.

  • Camadas de parallax.

    • Suporte a Pseudo-3D duplicando automaticamente uma camada várias vezes.
  • Iluminação 2D com mapas normais.

    • Sombras fortes e suaves.
  • Renderização de fonte utilizando bitmaps (BitmapFont) ou rasterização utilizando FreeType (DynamicFont).

    • Fontes em bitmap podem ser exportadas utilizando ferramentas como BMFont.
    • DynamicFont suporta fontes monocrómaticas bem como coloridas. Os formatos suportados são TTF e OTF.
    • DynamicFont suporta contornos opcionais para fontes, com ajustes de lagura e cor.
    • Suporte para sobreamostragem de fontes, permitindo que elas fiquem nítidas mesmo em resoluções mais altas.
  • Particulas baseadas em GPU com suporte para shaders personalizados de particulas.

  • Partículas em CPU.

Ferramentas 2D

  • Camera 2D com margens e suavização integrados.

  • O Nó Path2D para representar caminhos dentro de um espaço 2D.

    • Pode ser desenhado através do editor ou gerado proceduralmente.
    • O nó PathFollow2D para fazer os nós seguirem um Path2D.
  • Classe auxiliar para geometria 2D.

  • O nó Line2D para desenhar linhas 2D texturizadas.

Física 2D

Corpos com suporte a física:

  • Corpos estáticos.
  • Corpos rígidos.
  • Corpos cinemáticos.
  • Articulações/Junções.
  • Areas para detecção de entrada e saida de corpos.

Detecção de colisões:

  • formas integradas: linha, caixa, circulo e capsula.
  • Collision polygons (podem ser desenhados manualmente ou gerados a partir de um sprite pelo editor).

Gráficos 3D

Dois tipos de renderizadores disponíveis:

  • Renderizador OpenGL ES 3.0 (Utilize OpenGL ES 3.3 em plataformas desktop).
    • Visuais de alta nível. Recomendado para plataformas desktop.
    • Renderização de HDR com sRGB.
  • Renderizador OpenGL ES 2.0 (utilize OpenGL ES 2.1 em plataformas desktop).
    • Recomendado para plataformas Web e dispositivos móveis.
    • Renderização de LDR para melhor compatibilidade.
    • Nem todos os recursos estãos disponiveis. Os recursos disponiveis apenas ao utilizar OpenGL ES 3.0 estaram marcados com GLES3.

Câmera:

  • Câmeras em perspectiva, ortográfica e deslocamento de tronco.

Renderização baseada em física:

  • Segue o modelo Disney PBR.
  • Utiliza o fluxo de trabalho roughness-metallic com suporte para texturas ORM.
  • Mapeamento Normal.
  • GLES3: Mapeamento de Paralaxe/Relevo com níveis de detalhamento automático baseado na distancia.
  • GLES3: Dispersão e transmissão da sub-superfície.
  • GLES3: Desvanecimento de proximidade (partículas suaves).
  • Desvanecimento de distância que pode usar alpha blending ou dithering para evitar passar pelo pipeline transparente.
  • O pontilhamento pode ser determinado por pixel ou por objeto.

Iluminação em tempo real:

  • Luzes direcionadas (sol/lua). Até 4 por cena.
  • Luzes unidirecionais.
  • Focos de luz com ajuste de angulo por cone e atenuação.

Mapeamento de sombras:

  • Luz Direcional: Ortagonal (mais rápida), PSSM 2 divisões e 4 divisões. Suporta mesclagem entre divisões.
  • OmniLight: Dual paraboloid (fast) or cubemap (slower but more accurate). Supports colored projector textures in the form of panoramas.
  • Destaque: Testura única.

Iluminação global por luzes indiretas:

  • Mapa de luz pré-gerado ou Baked lightmaps (rápido, mas não pode ser atualizado durante a execução).

    • Mapas de luz (Lightmaps) são gerados pela CPU.
  • GLES3: GI probes (mais lento, semi-tempo real). Suporta reflexões.

Opções de execução:

  • GLES3: Reflexões baseadas em Voxel (ao utilizar GI probes).
  • Reflexões rápidas ou reflexões lentas em tempo real usando ReflectionProbe. A correção de paralaxe pode ser ativada opcionalmente.
  • GLES3: Reflexões de Screen-space.
  • Técnicas de reflexão podem ser combinadas para maior precisão.

Céu:

  • Céu de Panorama (utilizando HDRI).
  • Céu procedural.

Neblina:

  • Profundidade da neblina com ajuste de curva de atenuação.
  • Altura da neblina (Chão ou teto) com ajuste de atenuação.
  • Suporte para auto coloração de neblina a depender da direção da câmera (para se ajustar de acordo com a cor do sol).
  • Transmissão opcional para fazer com que as luzes sejam mais visíveis quando com neblina.

Partículas:

  • GLES3: Partículas baseados em GPU com suporte para shaders de partículas personalizado.
  • Partículas em CPU.

Processamento-póstumo:

  • Tonemapping (Linear, Reinhard, Filmic, ACES).
  • GLES3: Ajustes de exposição automáticos baseado no brilho da janela de visualização.
  • GLES3: Profundidade de campo próxima e distante.
  • GLES3: Screen-space ambient occlusion (SSAO - Oclusão de ambiente do espaço da tela).
  • Brilho/Bloom com escala bicúbica opcional e vários modos de combinação disponíveis: Tela, Luz Suave, Subexposição Linear, Substituir.
  • Correção de cor de rampa unidimensional.
  • Ajustes de brilho, contraste e saturação.

Texture filtering:

  • Filtragem mais próxima, bilinear, trilinear ou anisotrópica.

Texture compression:

  • GLES3: BPTC para compressão de alta qualidade (não é compatível com macOS).
  • GLES3: ETC2 (não é compatível com macOS).
  • ETC1 (recomendado ao utilizar o renderizador GLES2).
  • GLES3: S3TC (não é compatível com as plataformas móveis/Web).

Anti-aliasing:

  • Multi-sample antialiasing (MSAA).

A maioria desses efeitos pode ser ajustada para melhor desempenho ou para melhorar ainda mais a qualidade. Isso pode ser útil ao usar o Godot para renderização offline.

Ferramentas 3D

  • Malhas integradas: cubo, cilindro/cone, (hemi) esfera, prisma, plano, quad.

  • Ferramentas para geração de geometria procedural.

  • Geometria sólida construtiva (destinado para criação de protótipos).

  • Nó Path3D para representar um caminho no espaço 3D.

    • Pode ser desenhado através do editor ou gerado proceduralmente.
    • Nó PathFollow3D para fazer com que os nós sigam um Path3D.
  • Classe auxiliar de geometria 3D.

3D physics

Corpos com suporte a física:

  • Corpos estáticos.
  • Corpos rígidos.
  • Corpos cinemáticos.
  • Corpos de veículos (destinado para físicas arcade, não para simulação).
  • Articulações/Junções.
  • Corpos macios.
  • Ragdolls.
  • Areas para detecção de entrada e saida de corpos.

Detecção de colisões:

  • Built-in shapes: cuboid, sphere, capsule, cylinder (only with Bullet physics).
  • Generate triangle collision shapes for any mesh from the editor.
  • Generate one or several convex collision shapes for any mesh from the editor.

Shaders

  • 2D: Custom vertex, fragment, and light shaders.

  • 3D: Custom vertex, fragment, light, and sky shaders.

  • Text-based shaders using a shader language inspired by GLSL <doc_shading_language>.

  • Visual shader editor.

    • Support for visual shader plugins.

Scripting

Geral:

  • Object-oriented design pattern with scripts extending nodes.
  • Signals and groups for communicating between scripts.
  • Support for cross-language scripting.
  • Many 2D and 3D linear algebra data types such as vectors and transforms.

GDScript:

C#:

  • Packaged in a separate binary to keep file sizes and dependencies down.

  • Uses Mono 6.x.

    • Full support for the C# 7.0 syntax and features.
  • Supports all platforms.

  • Using an external editor is recommended to benefit from IDE functionality.

VisualScript:

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

  • When you need it, link to native libraries for higher performance and third-party integrations.

    • For scripting game logic, GDScript or C# are recommended if their performance is suitable.
  • Official bindings for C and C++.

    • Use any build system and language features you wish.
  • Maintained D, Kotlin, Python, Nim, and Rust bindings provided by the community.

Áudio

Funcionalidades:

  • Mono, stereo, 5.1 and 7.1 output.

  • Non-positional and positional playback in 2D and 3D.

    • Optional Doppler effect in 2D and 3D.
  • Support for re-routable audio buses and effects with dozens of effects included.

  • Listener3D node to listen from a position different than the camera in 3D.

  • Audio input to record microphones.

  • MIDI input.

    • No support for MIDI output yet.

APIs used:

  • Windows: WASAPI.
  • macOS: CoreAudio.
  • Linux: PulseAudio or ALSA.

Import

Formats:

  • Images: See Importing images.

  • Audio:

    • WAV with optional IMA-ADPCM compression.
    • Ogg Vorbis.
  • 3D scenes:

    • glTF 2.0 (recommended).
    • ESCN (direct export from Blender).
    • FBX (experimental).
    • Collada (.dae).
    • Wavefront OBJ (static scenes only, can be loaded directly as a mesh).

Entrada

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

    • Axis values can be mapped to two different actions with a configurable deadzone.
    • Use the same code to support both keyboards and gamepads.
  • Keyboard input.

    • Keys can be mapped in "physical" mode to be independent of the keyboard layout.
  • Mouse input.

    • The mouse cursor can be visible, hidden, captured or confined within the window.
    • When captured, raw input will be used on Windows and Linux to sidestep the OS' mouse acceleration settings.
  • Gamepad input (up to 8 simulatenous controllers).

  • Pen/tablet input with pressure support.

Trabalho em rede

  • Low-level TCP networking using StreamPeer and TCP_Server.

  • Low-level UDP networking using PacketPeer and UDPServer.

  • Low-level HTTP requests using HTTPClient.

  • High-level HTTP requests using HTTPRequest.

    • Supports HTTPS out of the box using bundled certificates.
  • High-level multiplayer API using UDP and ENet.

    • Automatic replication using remote procedure calls (RPCs).
    • Supports unreliable, reliable and ordered transfers.
  • 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.

Internacionalização

  • Full support for Unicode including emoji.
  • Store localization strings using CSV or gettext.
  • Use localized strings in your project automatically in GUI elements or by using the tr() function.
  • Support for right-to-left typesetting and text shaping planned in Godot 4.0.

Windowing and OS integration

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

  • Change the window title and icon.

  • Request attention (will cause the title bar to blink on most platforms).

  • Fullscreen mode.

    • Doesn't use exclusive fullscreen, so the screen resolution can't be changed this way. Use a Viewport with a different resolution instead.
  • Borderless window (fullscreen or non-fullscreen).

  • Ability to keep the window always on top.

  • Transparent window with per-pixel transparency.

  • Global menu integration on macOS.

  • Execute commands in a blocking or non-blocking manner.

  • Open file paths and URLs using default or custom protocol handlers (if registered on the system).

  • Parse custom command line arguments.

Mobile

  • In-app purchases on Android and iOS.
  • Support for advertisements using third-party modules.

XR support (AR and VR)

  • Support for ARKit on iOS out of the box.
  • Support for the OpenXR and OpenVR APIs.
  • Popular VR headsets like the Oculus Quest and HTC Vive are supported thanks to plugins.

GUI system

Godot's GUI is built using the same Control nodes used to make games in Godot. The editor UI can easily be extended in many ways using add-ons.

Nodes:

  • Buttons.
  • Checkboxes, check buttons, radio buttons.
  • Text entry using LineEdit (single line) and TextEdit (multiple lines).
  • Dropdown menus using PopupMenu and OptionButton.
  • Scrollbars.
  • Labels.
  • RichTextLabel for text formatted using BBCode.
  • Trees (can also be used to represent tables).
  • Containers (horizontal, vertical, grid, center, margin, draggable splitter, ...).
  • Controls can be rotated and scaled.

Sizing:

  • Anchors to keep GUI elements in a specific corner, edge or centered.

  • Containers to place GUI elements automatically following certain rules.

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

  • Support any aspect ratio using anchors and the expand stretch aspect.

Theming:

  • Built-in theme editor.

    • Generate a theme based on the current editor theme settings.
  • Procedural vector-based theming using StyleBoxFlat.

    • Supports rounded/beveled corners, drop shadows and per-border widths.
  • Texture-based theming using StyleBoxTexture.

Godot's small distribution size can make it a suitable alternative to frameworks like Electron or Qt.

Animação

  • Direct kinematics and inverse kinematics.
  • Support for animating any property with customizable interpolation.
  • Support for calling methods in animation tracks.
  • Support for playing sounds in animation tracks.
  • Support for Bézier curves in animation.

Formats

  • Scenes and resources can be saved in text-based or binary formats.

    • Text-based formats are human-readable and more friendly to version control.
    • Binary formats are faster to save/load for large scenes/resources.
  • Read and write text or binary files using File.

    • Can optionally be compressed or encrypted.
  • Read and write JSON files.

  • Read and write INI-style configuration files using ConfigFile.

    • Can (de)serialize any Godot datatype, including Vector, Color, ...
  • Read XML files using XMLParser.

  • Pack game data into a PCK file (custom format optimized for fast seeking), into a ZIP archive, or directly into the executable for single-file distribution.

  • Export additional PCK files that can be read by the engine to support mods and DLCs.

Diversos

  • Low-level access to servers which allows bypassing the scene tree's overhead when needed.

  • Command line interface for automation.

    • Export and deploy projects using continuous integration platforms.
    • Completion scripts are available for Bash, zsh and fish.
  • Support for C++ modules statically linked into the engine binary.

  • Engine and editor written in C++03.

    • Can be compiled using GCC, Clang and MSVC. MinGW is also supported.
    • Friendly towards packagers. In most cases, system libraries can be used instead of the ones provided by Godot. The build system doesn't download anything. Builds can be fully reproducible.
    • Godot 4.0 will be written in C++17.
  • Licensed under the permissive MIT license.

Ver também

O repositório roadmap documenta os recursos que foram acordados e podem ser implementados em versões futuras do Godot.