This translation is community contributed and may not be up to date. We only maintain the English version of the documentation. Read this manual in English
O Defold é, no seu núcleo, uma engine 3D. Mesmo quando você trabalha apenas com material 2D, toda renderização é feita em 3D, mas projetada ortograficamente na tela. O Defold permite usar conteúdo 3D completo incluindo assets 3D, ou Models, nas suas coleções. Você pode criar jogos estritamente 3D com apenas assets 3D, ou misturar conteúdo 3D e 2D como quiser.
Componentes Model são criados como qualquer outro componente de objeto de jogo. Você pode fazer isso de duas formas:

Com o modelo criado, você precisa especificar algumas propriedades:
Além das propriedades Id, Position e Rotation, existem as seguintes propriedades específicas do componente:
Além das propriedades acima, também haverá um campo para atribuir um material a cada malha do modelo:
gltf integrado para renderização fisicamente baseada das propriedades de material glTF, um material model integrado para sombreamento geral de modelos ou seu próprio material personalizado. Consulte as variantes de materiais abaixo e o manual de PBR.Dependendo do material, haverá uma ou mais propriedades de textura:
Selecionar uma Scene glTF ou GLB ou alterar sua seleção de Mesh pode oferecer o preenchimento dos vínculos de materiais e texturas. Auto Fill substitui os vínculos existentes pelos da origem; Keep Current preserva seus vínculos ao aplicar a nova seleção de cena ou malha. Consulte o fluxo de importação de modelos.
Com o componente model no lugar, você pode editar e manipular livremente o componente e/ou o objeto de jogo que o encapsula com as ferramentas normais do Scene Editor para mover, rotacionar e escalar o modelo como desejar.
Você pode manipular modelos em tempo de execução por meio de várias funções e propriedades diferentes (consulte a documentação da API para uso).

O Defold oferece suporte poderoso para controlar animação em tempo de execução. Mais no manual de animação de modelos:
local play_properties = { blend_duration = 0.1 }
model.play_anim("#model", "jump", go.PLAYBACK_ONCE_FORWARD, play_properties)
O cursor de reprodução da animação pode ser animado manualmente ou pelo sistema de animação de propriedades:
-- define a animação de corrida
model.play_anim("#model", "run", go.PLAYBACK_NONE)
-- anima o cursor
go.animate("#model", "cursor", go.PLAYBACK_LOOP_PINGPONG, 1, go.EASING_LINEAR, 10)
Modelos também podem usar animações glTF de morph target. Pesos de morph target são animados com model.play_anim() como outras animações de modelo, e podem ser lidos ou sobrescritos em tempo de execução usando model.get_blend_weights() e model.set_blend_weights(). Veja a seção de morph targets no manual de animação de modelos para detalhes.
Um modelo também tem várias propriedades diferentes que podem ser manipuladas usando go.get() e go.set():
animationhash) (SOMENTE LEITURA). Você altera a animação usando model.play_anim() (veja acima).cursornumber).materialhash). Você pode alterá-lo usando uma propriedade de recurso de material e go.set(). Consulte a referência da API para um exemplo.playback_ratenumber).textureNhash). Você pode ler essas propriedades com go.get() e alterá-las usando uma propriedade de recurso de textura e go.set(). O Defold oferece suporte a no máximo 16 texturas por draw, mas um shader pode usar menos em adaptadores gráficos com um limite menor de samplers de textura.Softwares 3D normalmente permitem definir propriedades nos vértices do seu objeto, como coloração e texturização. Essas informações vão para o arquivo glTF .gltf ou .glb que você exporta do seu software 3D. Dependendo dos requisitos do seu jogo, você terá que selecionar e/ou criar materiais apropriados e performáticos para seus objetos. Um material combina programas de shader com um conjunto de parâmetros para renderização do objeto.
Os seguintes materiais integrados estão disponíveis em /builtins/materials/:
| Tipo de modelo | Sombreamento geral de modelos | Sombreamento PBR glTF |
|---|---|---|
| Estático, sem instâncias | model.material |
gltf.material |
| Estático, com instâncias | model_instanced.material |
gltf_instanced.material |
| Com skinning (animado), sem instâncias | model_skinned.material |
gltf_skinned.material |
| Com skinning (animado), com instâncias | model_skinned_instanced.material |
gltf_skinned_instanced.material |
Os materiais gltf oferecem iluminação integrada baseada em metalicidade/rugosidade usando os dados de material glTF importados. Consulte o manual de PBR para conhecer vínculos de texturas, luzes e shaders personalizados.
Todos esses materiais integrados usam espaço de vértices local. Em modelos com skinning, o espaço local permite que o vertex shader faça skinning na GPU usando uma textura de matrizes dos ossos; o espaço local também é necessário para instanciamento de modelos. Portanto, um material personalizado destinado a modelos com skinning na GPU ou instanciados deve usar a configuração de espaço de vértices Local.
O cache de matrizes de ossos usa uma textura RGBA32F. Se o adaptador gráfico ativo não oferecer suporte a esse formato de textura, o Defold não poderá criar um componente Model animado que use um material de espaço local. No OpenGL ES 2.0 e WebGL 1.0, o suporte depende, portanto, da extensão de texturas de ponto flutuante do adaptador. Para ter compatibilidade com um adaptador que não ofereça esse recurso, use um material personalizado de espaço de mundo, que usa skinning na CPU e não pode usar instancing de modelos. As dimensões do cache podem ser ajustadas nas configurações de projeto de Model.
Se você precisar criar materiais personalizados para seus modelos, consulte a documentação de Material para informações. O manual de Shader contém informações sobre como os programas de shader funcionam.
O material padrão model tem as seguintes constantes, que podem ser alteradas usando go.set() ou go.animate() (consulte o manual de Material para mais detalhes). Exemplos:
go.set("#model", "tint", vmath.vector4(1,0,0,1))
go.animate("#model", "tint", go.PLAYBACK_LOOP_PINGPONG, vmath.vector4(1,0,0,1), go.EASING_LINEAR, 2)
tintvector4). O vector4 é usado para representar o tint com x, y, z e w correspondendo ao tint vermelho, verde, azul e alfa.O script de renderização padrão desenha materiais com a tag model, incluindo os materiais integrados de modelos e glTF. Para renderizá-los em um script de renderização personalizado, crie um predicado correspondente e desenhe-o com uma matriz de visualização e uma projeção adequadas à cena. Por exemplo:
function init(self)
self.model_pred = render.predicate({"model"})
...
end
function update()
...
render.set_depth_mask(true)
render.enable_state(graphics.STATE_DEPTH_TEST)
render.set_projection(stretch_projection(-1000, 1000)) -- ortográfica
render.draw(self.model_pred)
render.set_depth_mask(false)
...
end
Veja a documentação de Render para detalhes sobre como scripts de renderização funcionam.