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

Defold es, en esencia, un motor 3D. Incluso cuando trabajas solo con material 2D, todo el renderizado se realiza en 3D, pero se proyecta ortográficamente en la pantalla. Defold te permite usar contenido 3D completo al incluir assets 3D, o modelos, en tus colecciones. Puedes crear juegos estrictamente en 3D solo con assets 3D, o puedes mezclar contenido 3D y 2D como prefieras.

Crear un componente Model

Los componentes Model se crean igual que cualquier otro componente de objeto de juego. Puedes hacerlo de dos formas:

  • Crea un archivo Model con click derecho en una ubicación del explorador Assets y selecciona New... ▸ Model.
  • Crea el componente incrustado directamente en un objeto de juego con click derecho en un objeto de juego en la vista Outline y selecciona Add Component ▸ Model.

Model en objeto de juego

Una vez creado el modelo, debes especificar varias propiedades:

Propiedades de Model

Aparte de las propiedades Id, Position y Rotation, existen las siguientes propiedades específicas del componente:

Scene
El archivo glTF .gltf o .glb que contiene la geometría del modelo. Si contiene morph targets, se importan junto con la escena. Esta propiedad se llamaba antes Mesh.
Mesh
Una malla con nombre opcional de la Scene seleccionada. Deja el campo vacío para renderizar toda la escena con sus transformaciones importadas. Selecciona una malla para renderizarla una vez en sus coordenadas locales, sin las transformaciones de los nodos glTF. Coloca, rota y escala el componente Model o su objeto de juego para situar la malla seleccionada.
Create GO Bones
Activa esto para crear un objeto de juego por cada hueso del modelo. Puedes usar los objetos de juego para adjuntar otros objetos de juego, como armas, a los huesos de las manos y casos similares.
Skeleton
Esta propiedad debe hacer referencia al archivo glTF .gltf o .glb que contiene el esqueleto que se va a usar para la animación. Ten en cuenta que Defold requiere un único hueso raíz en la jerarquía.
Animations
Define esta propiedad con el Animation Set File que contiene las animaciones que quieres usar en el modelo.
Default Animation
Esta es la animación (del animation set) que se reproducirá automáticamente en el modelo.

Además de las propiedades anteriores, también habrá un campo para asignar un material por cada malla del modelo:

Material
Establece esta propiedad con un material adecuado para el modelo. Usa un material gltf integrado para renderizado basado en física de las propiedades del material glTF, un material model integrado para sombreado general de modelos o tu propio material personalizado. Consulta las variantes de materiales más abajo y el manual de PBR.

Según el material, habrá una o más propiedades de textura:

Texture
Esta propiedad debe apuntar a la imagen de textura que quieras aplicar al objeto. Puede ser un asset independiente del proyecto o una imagen integrada expuesta bajo un archivo glTF o GLB en el panel Assets.

Seleccionar una Scene glTF o GLB, o cambiar su selección Mesh, puede ofrecer completar las asignaciones de materiales y texturas. Auto Fill reemplaza las asignaciones existentes con las del origen; Keep Current conserva tus asignaciones mientras aplica la nueva selección de escena o malla. Consulta el flujo de importación de modelos.

Manipulación en el editor

Con el componente Model en su lugar, puedes editar y manipular libremente el componente y/o el objeto de juego que lo encapsula con las herramientas habituales de Scene Editor para mover, rotar y escalar el modelo a tu gusto.

Manipulación en runtime

Puedes manipular modelos en runtime mediante varias funciones y propiedades diferentes (consulta la documentación de la API para su uso).

Wiggler en el juego

Animación en runtime

Defold proporciona soporte potente para controlar la animación en runtime. Más información en el manual de animación de modelos:

local play_properties = { blend_duration = 0.1 }
model.play_anim("#model", "jump", go.PLAYBACK_ONCE_FORWARD, play_properties)

El cursor de reproducción de animación se puede animar a mano o mediante el sistema de animación de propiedades:

-- define la animación run
model.play_anim("#model", "run", go.PLAYBACK_NONE)
-- anima el cursor
go.animate("#model", "cursor", go.PLAYBACK_LOOP_PINGPONG, 1, go.EASING_LINEAR, 10)

Los modelos también pueden usar animaciones de morph targets de glTF. Los pesos de los morph targets se animan con model.play_anim() igual que otras animaciones de modelos, y se pueden leer o sobrescribir en runtime con model.get_blend_weights() y model.set_blend_weights(). Consulta la sección de morph targets en el manual de animación de modelos para más detalles.

Cambiar propiedades

Un modelo también tiene varias propiedades diferentes que pueden manipularse con go.get() y go.set():

animation
La animación actual del modelo (hash) (solo lectura). Cambias la animación usando model.play_anim() (ver arriba).
cursor
El cursor de animación normalizado (number).
material
El material del modelo (hash). Puedes cambiarlo usando una propiedad de recurso de material y go.set(). Consulta la referencia de la API para ver un ejemplo.
playback_rate
La tasa de reproducción de la animación (number).
textureN
Las texturas del modelo donde N va de 0 a 15 (hash). Puedes leer estas propiedades con go.get() y modificarlas mediante una propiedad de recurso de textura y go.set(). Defold admite como máximo 16 texturas por draw, pero la cantidad que puede usar un shader podría ser menor en adaptadores gráficos con un límite inferior de samplers de textura.

Material

El software 3D suele permitirte definir propiedades en los vértices del objeto, como color y texturas. Esta información se guarda en el archivo glTF .gltf o .glb que exportas desde tu software 3D. Según los requisitos de tu juego, tendrás que seleccionar y/o crear materiales adecuados y eficientes para tus objetos. Un material combina programas de shader con un conjunto de parámetros para renderizar el objeto.

Los siguientes materiales integrados están disponibles en /builtins/materials/:

Tipo de modelo Sombreado general de modelos Sombreado PBR glTF
Estático, sin instancias model.material gltf.material
Estático, con instancias model_instanced.material gltf_instanced.material
Con skinning (animado), sin instancias model_skinned.material gltf_skinned.material
Con skinning (animado), con instancias model_skinned_instanced.material gltf_skinned_instanced.material

Los materiales gltf proporcionan iluminación metálica/rugosa integrada usando los datos del material glTF importado. Consulta el manual de PBR para conocer las asignaciones de texturas, las luces y los shaders personalizados.

Todos estos materiales integrados usan espacio de vértices local. En modelos con skinning, el espacio local permite que el vertex shader realice el skinning en la GPU mediante una textura de matrices de huesos; también se requiere para las instancias de modelos. Por tanto, un material personalizado para modelos con skinning en GPU o instancias debe usar el ajuste de espacio de vértices Local.

La caché de matrices de huesos usa una textura RGBA32F. Si el adaptador gráfico activo no admite ese formato de textura, Defold no puede crear un componente Model animado que use un material en espacio local. En OpenGL ES 2.0 y WebGL 1.0, la compatibilidad depende por tanto de la extensión de texturas de punto flotante del adaptador. Para ser compatible con un adaptador que no la incluya, usa un material personalizado en espacio del mundo, que emplea skinning por CPU y no admite instancing de modelos. Las dimensiones de la caché pueden ajustarse en las opciones de proyecto de Model.

Si necesitas crear materiales personalizados para tus modelos, consulta la documentación de Material para más información. El manual de Shader contiene información sobre cómo funcionan los programas de shader.

Constantes del material

El material predeterminado de model tiene las siguientes constantes que se pueden cambiar con go.set() o go.animate() (consulta el manual de Material para más detalles). Ejemplos:

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
El tinte de color del modelo (vector4). El vector4 se usa para representar el tinte con x, y, z y w correspondientes al tinte rojo, verde, azul y alfa.

Renderizado

El script de render predeterminado dibuja materiales con la etiqueta model, incluidos los materiales integrados de modelos y glTF. Para renderizarlos en un script personalizado, crea un predicado correspondiente y dibújalo con una vista y proyección adecuadas para la escena. Por ejemplo:


  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

Consulta la documentación de Render para más detalles sobre cómo funcionan los scripts de render.