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
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.
Los componentes Model se crean igual que cualquier otro componente de objeto de juego. Puedes hacerlo de dos formas:

Una vez creado el modelo, debes especificar varias propiedades:
Aparte de las propiedades Id, Position y Rotation, existen las siguientes propiedades específicas del componente:
Además de las propiedades anteriores, también habrá un campo para asignar un material por cada malla del modelo:
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:
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.
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.
Puedes manipular modelos en runtime mediante varias funciones y propiedades diferentes (consulta la documentación de la API para su uso).

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.
Un modelo también tiene varias propiedades diferentes que pueden manipularse con go.get() y go.set():
animationhash) (solo lectura). Cambias la animación usando model.play_anim() (ver arriba).cursornumber).materialhash). Puedes cambiarlo usando una propiedad de recurso de material y go.set(). Consulta la referencia de la API para ver un ejemplo.playback_ratenumber).textureNhash). 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.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.
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)
tintvector4). El vector4 se usa para representar el tinte con x, y, z y w correspondientes al tinte rojo, verde, azul y alfa.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.