Attention: Here be dragons

This is the latest (unstable) version of this documentation, which may document features not available in or compatible with released stable versions of Godot.

Checking the stable version of the documentation...

Coordenadas de mundo grande

Nota

Coordenadas de mundo grande são úteis principalmente em projetos 3D; elas raramente são necessárias em projetos 2D. Além disso, ao contrário da renderização 3D, a renderização 2D atualmente não se beneficia do aumento de precisão quando as coordenadas de mundo grande estão ativadas.

Porque usar grandes corrdenadas do mundo?

No Godot, a simulação física e a renderização dependem de números de ponto flutuante. No entanto, na computação, números de ponto flutuante têm precisão e alcance limitados. Isso pode ser um problema para jogos com mundos enormes, como jogos de simulação em escala espacial ou planetária.

A precisão é maior quando o valor está próximo de 0.0. A precisão torna-se gradualmente menor à medida que o valor aumenta ou diminui para longe de 0.0. Isso ocorre toda vez que o expoente do número de ponto flutuante aumenta, o que acontece quando o número de ponto flutuante ultrapassa um valor de potência de 2 (2, 4, 8, 16, …). Toda vez que isso ocorre, o passo mínimo do número vai aumentar, resultando em uma perda de precisão.

Na prática, isso significa que à medida que o jogador se afasta da origem do mundo (Vector2(0, 0) em jogos 2D ou Vector3(0, 0, 0) em jogos 3D), a precisão diminuirá.

Essa perda de precisão pode fazer com que os objetos pareçam "vibrar" quando estão longe da origem do mundo, pois a posição do modelo se ajustará ao valor mais próximo que puder ser representado em um número de ponto flutuante. Isso também pode resultar em falhas de física que ocorrem apenas quando o jogador está longe da origem do mundo.

O alcance determina os valores mínimo e máximo que podem ser armazenados no número. Se o jogador tentar se mover além desse alcance, ele simplesmente não conseguirá. No entanto, na prática, a precisão do ponto flutuante quase sempre se torna um problema antes do alcance.

O alcance e a precisão (passo mínimo entre dois intervalos de expoentes) são determinados pelo tipo de número de ponto flutuante. O alcance teórico permite que valores extremamente altos sejam armazenados em floats de precisão simples, mas com precisão muito baixa. Na prática, um tipo de ponto flutuante que não pode representar todos os valores inteiros não é muito útil. Em valores extremos, a precisão torna-se tão baixa que o número não consegue sequer distinguir dois valores inteiros separados um do outro.

Este é o alcance onde valores inteiros individuais podem ser representados em um número de ponto flutuante:

• Alcance do float de precisão simples (representa todos os inteiros): Entre -16.777.216 e 16.777.216

• Alcance do float de precisão dupla (representa todos os inteiros): Entre -9 quatrilhões e 9 quatrilhões

Alcance	Passo único	Passo duplo	Comente
[1; 2]	~0.0000001	~1e-15	A precisão torna-se maior perto de 0.0 (esta tabela está abreviada).
[2; 4]	~0.0000002	~1e-15
[4; 8]	~0.0000005	~1e-15
[8; 16]	~0.000001	~1e-14
[16; 32]	~0.000002	~1e-14
[32; 64]	~0.000004	~1e-14
[64; 128]	~0.000008	~1e-13
[128; 256]	~0.000015	~1e-13
[256; 512]	~0.00003	~1e-13
[512; 1024]	~0.00006	~1e-12
[1024; 2048]	~0.0001	~1e-12
[2048; 4096]	~0.0002	~1e-12	Alcance máximo de precisão simples recomendado para um jogo 3D em primeira pessoa, sem artefatos de renderização ou falhas de física.
[4096; 8192]	~0.0005	~1e-12	Alcance máximo de precisão simples recomendado para um jogo 3D em terceira pessoa, sem artefatos de renderização ou falhas de física.
[8192; 16384]	~0.001	~1e-12
[16384; 32768]	~0.0019	~1e-11	Alcance máximo de precisão simples recomendado para um jogo 3D com visão top-down, sem artefatos de renderização ou falhas de física.
[32768; 65536]	~0.0039	~1e-11	Alcance máximo de precisão simples recomendado para qualquer jogo 3D. Precisão dupla (coordenadas de mundo grande) geralmente é necessária após este ponto.
[65536; 131072]	~0.0078	~1e-11
[131072; 262144]	~0.0156	~1e-10
> 262144	> ~0.0313	~1e-10 (0.0000000001)	A precisão dupla permanece muito mais precisa do que a precisão simples após este valor.

Ao usar floats de precisão simples, é possível ir além dos alcances sugeridos, mas ocorrerão artefatos mais visíveis e falhas de física serão mais comuns (como o jogador não andar reto em certas direções).

Ver também

Consulte o artigo Demystifying Floating Point Precision para mais informações.

Como funcionam as coordenadas de mundo grande

Coordenadas de mundo grande (também conhecidas como física de precisão dupla) aumentam o nível de precisão de todos os cálculos de ponto flutuante dentro do motor.

Por padrão, float tem 64 bits no GDScript, mas Vector2, Vector3 e Vector4 têm 32 bits. Isso significa que a precisão dos tipos de vetores é muito mais limitada. Para resolver isso, podemos aumentar o número de bits usados para representar un número de ponto flutuante em um tipo Vector. Isso resulta em um aumento exponencial na precisão, o que significa que o valor final não é apenas duas vezes mais preciso, mas potencialmente milhares de vezes mais preciso em valores altos. O valor máximo que pode ser representado também é bastante aumentado ao passar de um float de precisão simples para um float de precisão dupla.

Para evitar problemas de 'snapping' (estalo) de modelo quando longe da origem do mundo, o mecanismo de renderização 3D do Godot aumentará sua precisão para operações de renderização quando grandes coordenadas mundiais estiverem habilitadas. Os shaders não usam floats de dupla precisão por motivos de desempenho, mas uma solução alternativa é usada para emular precisão dupla para renderização usando floats de precisão simples.

Nota

Ativar coordenadas de mundo grande traz uma penalidade de desempenho e uso de memória, especialmente em CPUs de 32 bits. Ative as coordenadas de mundo grande apenas se você realmente precisar delas.

Este recurso é voltado para plataformas de desktop de médio/alto desempenho. Coordenadas de mundo grande podem não funcionar bem em dispositivos móveis de baixo desempenho, a menos que você tome medidas para reduzir o uso da CPU por outros meios (como diminuir o número de tiques de física por segundo).

Em plataformas de baixo desempenho, uma abordagem de deslocamento de origem (origin shifting) pode ser usada para permitir mundos grandes sem usar física e renderização de dupla precisão. O deslocamento de origem funciona com floats de precisão simples, mas introduz mais complexidade à lógica do jogo, especialmente em jogos multiplayer. Portanto, o deslocamento de origem não é detalhado nesta página.

Para quem são as coordenadas de mundo grande?

Coordenadas de mundo grande são normalmente necessárias para jogos de simulação espacial 3D ou em escala planetária. Isso se estende a jogos que precisam suportar velocidades de movimento muito rápidas, mas também movimentos muito lentos e precisos às vezes.

Por outro lado, é importante usar coordenadas de mundo grande apenas quando realmente necessário (por razões de desempenho). Coordenadas de mundo grande geralmente não são necessárias para:

• Jogos 2D, já que os problemas de precisão costumam ser menos perceptíveis.

• Jogos com mundos de pequena ou média escala.

• Jogos com mundos grandes, mas divididos em fases ou níveis diferentes com telas de carregamento entre eles. Você pode centralizar cada parte do nível em torno da origem do mundo para evitar problemas de precisão sem sofrer penalidade de desempenho.

• Jogos de mundo aberto com uma área jogável a pé que não exceda 8192×8192 metros (centralizada em torno da origem do mundo). Como mostrado na tabela acima, o nível de precisão permanece aceitável dentro desse alcance, mesmo para um jogo em primeira pessoa.

Em caso de dúvida, você provavelmente não precisa usar coordenadas de mundo grande em seu projeto. Para referência, a maioria dos títulos modernos de mundo aberto AAA não usa um sistema de coordenadas de mundo grande e ainda depende de floats de precisão simples tanto para renderização quanto para física.

Habilitando coordenadas de mundo grande

Este processo requer a recompilação do editor e de todos os binários de modelos de exportação que você pretende usar. Se você pretende apenas exportar seu projeto no modo de lançamento (release), você pode pular a compilação de modelos de exportação de depuração (debug). Em qualquer caso, você precisará compilar uma versão do editor para poder testar seu mundo de alta precisão sem ter que exportar o projeto todas as vezes.

Consulte a seção Compiling para obter instruções de compilação para cada plataforma de destino. Você precisará adicionar a opção do SCons precision=double ao compilar o editor e os modelos de exportação.

Os binários resultantes serão nomeados com um sufixo .double para distingui-los dos binários de precisão simples (que não possuem nenhum sufixo de precisão). Você pode então especificar os binários como modelos de exportação personalizados nas predefinições de exportação do seu projeto na janela Exportar.

Compatibilidade entre versões de precisão simples e precisão dupla

Ao salvar um recurso binário usando o singleton ResourceSaver, uma flag especial é armazenada no arquivo se o recurso foi salvo usando uma versão que utiliza números de precisão dupla. Como resultado, todos os recursos binários serão alterados no disco quando você mudar para uma versão de precisão dupla e salvar por cima deles.

Tanto as versões de precisão simples quanto as de precisão dupla suportam o uso do singleton ResourceLoader em recursos que utilizam essa flag especial. Isso significa que as versões de precisão simples podem carregar recursos salvos usando versões de precisão dupla e vice-versa. Recursos baseados em texto não armazenam uma flag de precisão dupla, pois não exigem tal flag para uma leitura correta.

Incompatibilidades conhecidas

• Em um jogo multijogador em rede, o servidor e todos os clientes devem usar o mesmo tipo de versão para garantir que a precisão permaneça consistente entre os clientes. O uso de tipos de versões diferentes pode funcionar, mas vários problemas podem ocorrer.

• A API do GDExtension muda de uma forma incompatível em versões de precisão dupla. Isso significa que as extensões devem ser reconstruídas para funcionar com versões de precisão dupla. Do lado do desenvolvedor da extensão, a definição REAL_T_IS_DOUBLE é ativada ao compilar um GDExtension com precision=double. real_t pode ser usado como um apelido para float em versões de precisão simples, e double em versões de precisão dupla.

Limitações

Como os shaders de renderização 3D não usam de fato floats de precisão dupla, existem algumas limitações quando se trata da precisão da renderização 3D:

• O mapeamento triplanar não se beneficia do aumento de precisão. Materiais que usam mapeamento triplanar exibirão uma tremulação visível quando estiverem longe da origem do mundo.

• Nós GPUParticles3D com Local Coords desabilitado não se beneficiarão da precisão aumentada. Isso pode causar um 'snapping' visível de partículas ao ocorrer longe da origem do mundo. Nós com Local Coords habilitado, bem como nós CPUParticles3D, ainda se beneficiarão da precisão aumentada.

• Shaders que usam os modos de renderização skip_vertex_transform ou world_vertex_coords não se beneficiam do aumento de precisão.

• Em builds de dupla precisão, as coordenadas do espaço do mundo em uma função de shader fragment() não podem ser reconstruídas a partir do espaço de visão, por exemplo:

  vec3 world = (INV_VIEW_MATRIX * vec4(VERTEX, 1.0)).xyz;
  

  Em vez disso, calcule as coordenadas do espaço de mundo na função vertex() e passe-as usando um varying, por exemplo:

  varying vec3 world;
  void vertex() {
      world = (MODEL_MATRIX * vec4(VERTEX, 1.0)).xyz;
  }
  

A renderização 2D atualmente não se beneficia do aumento de precisão quando as coordenadas de mundo grande estão ativadas. Isso pode fazer com que ocorra um efeito visível de snapping do modelo quando longe da origem do mundo (começando a partir de alguns milhões de pixels em níveis típicos de zoom). Os cálculos de física 2D, no entanto, ainda se beneficiarão do aumento de precisão.