Manuals
Manuals




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

Componente Model

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.

Criando um componente model

Componentes Model são criados como qualquer outro componente de objeto de jogo. Você pode fazer isso de duas formas:

  • Crie um arquivo Model com clique com o botão direito em um local no navegador Conteúdo e selecione Novo... ▸ Modelo.
  • Crie o componente incorporado diretamente em um objeto de jogo com clique com o botão direito em um objeto de jogo na visualização Estrutura e selecione Adicionar Componente ▸ Modelo.

Modelo no objeto de jogo

Com o modelo criado, você precisa especificar algumas propriedades:

Propriedades de model

Além das propriedades Id, Position e Rotation, existem as seguintes propriedades específicas do componente:

Scene
O arquivo glTF .gltf ou .glb que contém a geometria do modelo. Se o arquivo contiver morph targets, eles serão importados junto com a cena. Esta propriedade se chamava Mesh anteriormente.
Mesh
Uma malha nomeada opcional da Scene selecionada. Deixe este campo vazio para renderizar a cena inteira com suas transformações importadas. Selecione uma malha para renderizá-la uma vez em suas coordenadas locais, sem as transformações dos nós glTF. Posicione, rotacione e redimensione o componente Model ou seu objeto de jogo para posicionar a malha selecionada.
Create GO Bones
Marque isto para criar um objeto de jogo para cada osso do modelo. Você pode usar os objetos de jogo para anexar outros objetos de jogo, como armas, a ossos das mãos e assim por diante.
Skeleton
Esta propriedade deve referenciar o arquivo glTF .gltf ou .glb que contém o esqueleto a usar para animação. Observe que o Defold exige um único osso raiz na sua hierarquia.
Animations
Defina isto para o Animation Set File que contém as animações que você deseja usar no modelo.
Default Animation
Esta é a animação (do conjunto de animações) que será reproduzida automaticamente no modelo.

Além das propriedades acima, também haverá um campo para atribuir um material a cada malha do modelo:

Material
Defina esta propriedade como um material adequado ao modelo. Use um material 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:

Texture
Esta propriedade deve apontar para a imagem de textura que você deseja aplicar ao objeto. Pode ser um asset separado do projeto ou uma imagem incorporada exposta sob um arquivo glTF ou GLB no painel Assets.

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.

Manipulação no editor

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.

Manipulação em tempo de execução

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).

Wiggler no jogo

Animação em tempo de execução

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.

Alterando propriedades

Um modelo também tem várias propriedades diferentes que podem ser manipuladas usando go.get() e go.set():

animation
A animação atual do modelo (hash) (SOMENTE LEITURA). Você altera a animação usando model.play_anim() (veja acima).
cursor
O cursor normalizado da animação (number).
material
O material do modelo (hash). Você pode alterá-lo usando uma propriedade de recurso de material e go.set(). Consulte a referência da API para um exemplo.
playback_rate
A taxa de reprodução da animação (number).
textureN
As texturas do modelo, onde N é 0-15 (hash). 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.

Material

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.

Constantes de material

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)
tint
O tint de cor do modelo (vector4). O vector4 é usado para representar o tint com x, y, z e w correspondendo ao tint vermelho, verde, azul e alfa.

Renderização

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.

⌂ 换网址