Sistema de evolución dinámico para criaturas 3D

Trabajo de fin de grado Sistema de evolución dinámico para criaturas 3D Por David García Morán 4ª Curso de Grado en Diseño y Desarrollo de Videojuegos, Programación Investigación realizada en complemento al videojuego “Reverie Island” Videojuego creado por Sweetcare Games Fecha de publicación: 12-06-2023

Sistema de evolución dinámico Índice Contenido Índice ............................................................................................................................. 2 Agradecimentos...........................................................................................................5 Resumen ......................................................................................................................6 Abstract .........................................................................................................................7 Introducción .................................................................................................................. 8 Parte Grupal .............................................................................................................9 Información del juego .........................................................................................9 Parte individual ........................................................................................................9 Objetivos generales ..................................................................................................10 Objetivos del videojuego......................................................................................10 Principales .......................................................................................................... 10 Secundarios .......................................................................................................10 Objetivos de la investigación...............................................................................10 Principales .......................................................................................................... 10 Secundarios .......................................................................................................10 Estado de la cuestión ............................................................................................... 11 Metodología................................................................................................................12 Desarrollo del proyecto ............................................................................................13 Roles de programación ........................................................................................13 Análisis....................................................................................................................13 pág. 2

Sistema de evolución dinámico Realización de tareas ...........................................................................................13 Tareas de desarrollo del videojuego ..............................................................13 Tareas de investigación....................................................................................14 Resultados y conclusiones......................................................................................17 Resultados..............................................................................................................17 Conclusiones..........................................................................................................18 Post Mortem ...............................................................................................................20 Parte de la investigación......................................................................................20 Parte del videojuego.............................................................................................20 Anexos ........................................................................................................................21 Documentación del código ..................................................................................21 Documentación de la investigación................................................................21 Documentación del videojuego.......................................................................21 Requisitos mínimos del proyecto ........................................................................24 Estructura del proyecto ........................................................................................25 Estructura de la investigación .........................................................................25 Estructura del videojuego ................................................................................25 Manual del proyecto..............................................................................................26 Manual de la investigación ..............................................................................26 Manual del videojuego......................................................................................26 Archivos fuente ......................................................................................................26 pág. 3

Sistema de evolución dinámico Binarios distribuibles.............................................................................................27 Referencias ................................................................................................................28 pág. 4

Sistema de evolución dinámico Agradecimentos Agradecimientos a todo el equipo de Sweetcare Games, mi familia y amigos. pág. 5

Sistema de evolución dinámico Resumen Hoy en día hay muchos filtros que permiten ver a una persona joven de tal forma que en la foto o vídeo generado tiene una edad avanzada, gracias a complejos sistemas de redes neuronales, pero solo se puede aplicar a simples fotos o vídeos de personas y con una gran base de datos de fondo, por lo tanto, no es una buena solución para un modelo 3D. Se busca una aplicación más general que permitirá simular la evolución de la malla de una criatura, destinada a un videojuego para el motor Unity, en su forma y textura, siguiendo una visión artística para conseguirlo. En este proyecto se aplicará sistema de BlendShapes para conseguir una progresión en el tiempo sobre la maya del modelo 3D y conseguir un resultado de una criatura creciendo con el paso del tiempo. Palabras clave: Evolución, videojuego, BlendShapes, 3D pág. 6

Sistema de evolución dinámico Abstract Nowadays there are many filters that allow to see a young person in such a way that in the generated photo or video has an advanced age, thanks to complex neural network systems, but it can only be applied to simple photos or videos of people and with a large database as background, therefore, it is not a good solution for a 3D model. A better general application is needed that will allow to simulate the evolution of the mesh of a creature, intended for a video game made in Unity engine, in its shape and texture, following an artistic vision to achieve it. In this project BlendShapes system will be applied to achieve a progression in time on the 3D model and get a result of a creature growing over time. Keywords: Evolution, video game, BlendShapes, 3D pág. 7

Sistema de evolución dinámico Introducción En los videojuegos a veces es necesario que un objeto cambie en tiempo real ya sea de forma, su textura o ciertas características para satisfacer al usuario y generar un juego más original y divertido. En el caso de objetos 3D es más complicado ya que hay muchas más limitaciones de memoria, trabajo artístico y complejidad al tratar objetos de muchos polígonos. En esta investigación se trata un modelo 3D de una criatura acuática diseñada para un videojuego con el objetivo de que pueda crecer con el paso del tiempo. Se aplicará una técnica con “BlendShapes” o mejor conocidos como “Morph targets” que se define así: “Es una técnica usada en animación para transformar una forma en otra. En 3D recibe adicionalmente los nombres de \"per-vertex animation\", \"shape blending\" o \"shape interpolation\"”. (Torres, 2015). Después de estudiar esta técnica, se decide usar el programa Blender, uno de los programas más usados para modelado 3D, para modificar las BlendShapes de una forma sencilla que se explicará más adelante. Gracias a esas BlendShapes, se pudo exportar un modelo compatible con Unity, un motor para la creación de videojuegos, donde se leyeron los parámetros gracias al lenguaje de programación C# soportado en el motor. Como resultado, se genera una escena donde pueden apreciarse diversos cambios según los parámetros de edad y hambre, esto demuestra que es posible adaptar BlendShapes a cambios en tiempo real a pesar de algunas desventajas entre las que están la deformación de la textura y límites respecto a generar nueva geometría. A continuación, se explicará el trabajo detallado de cada parte del proyecto y del videojuego Reverie Island por separado, ya que no se pudo implementar la investigación al juego final por incompatibilidad de diseño y complicaciones en el desarrollo principal. pág. 8

Sistema de evolución dinámico Parte Grupal Información del juego • Descripción: Juego donde cuidas criaturas en una isla. • Género: Simulación 1º Persona • Ambientación: Isla fantástica, tropical. • Plataformas: Itch.io • Público: 3+ años, todos los públicos Parte individual Por esta parte, se trabajó la investigación gracias a los programas Blender y Unity, usando un modelo 3D de una criatura acuática, creado por Sara Jiménez y usado en el juego Reverie Island. Las principales tareas de esta parte fueron: • Búsqueda de tutoriales de Blender y sobre BlendShapes • Aplicar técnicas aprendidas • Implementación en Unity del sistema de tiempo. • Implementación de los parámetros de la criatura Respecto al videojuego se hicieron estas tareas de una forma general, se entrará en detalle más adelante según el trabajo semanal. • Inicio del proyecto y primeras pruebas de IA • Cámara • Bake del Navigation mesh • Implementar acciones de las criaturas • Implementar juegos • Arreglo de bugs pág. 9

Sistema de evolución dinámico Objetivos generales Objetivos del videojuego Principales • Crear juego con temática alegre y tranquila • Implementar funcionamiento completo a 2 criaturas • Interactuar con las criaturas • Jugar con las criaturas para desbloquear recompensas Secundarios • Implementar las 4 criaturas • Escenario más grande • Minijuegos Objetivos de la investigación Principales • Evolucionar el modelo de una criatura modificando su maya 3D • Aplicar en tiempo real para un videojuego • Generar una textura diferente Secundarios • Buen resultado visual • Implementación en el videojuego Reverie Island • Aplicar a otro modelo 3D diferente para probar más transformaciones pág. 10

Sistema de evolución dinámico Estado de la cuestión No hay muchas investigaciones sobre la modificación de un modelo para hacerlo evolucionar, por ejemplo, la investigación de Igor Santesteban: (Santesteban, 2017) , no usa un método adecuado para alguien que no es artista, ya que hay que aplicar un sistema de huesos y no es tan intuitivo, a parte, de ser más complicado de leer a nivel de código. También tuve en cuenta el sistema de nube de puntos para generar evoluciones de las criaturas, pero además de ser un sistema con mucha carga artística, la API no es gratuita y podría dar problemas al tener que generar nuevas colisiones en tiempo real. (Frozen Mist, 2020) Al final se aceptó la solución de las BlendShapes gracias a unos vídeos que hicieron de base de aprendizaje para este proyecto: (Glauz, 2016). En estos vídeos se aplican las BlendShapes para modificar la personalización inicial de un personaje, un uso común de las BlendShapes, pero en este caso, se pensó en algo más dinámico como el paso del tiempo en un juego, por lo que se pueden modificar valores entre 0 a 100 en el backend, con la tecnología moderna no da grandes problemas ya que son estados que hacen una interpolación suave siempre que no sea un cambio que rompa la geometría del modelo, se puede realizar en Unity desde hace mucho tiempo por lo que no debería ser un problema en ningún caso. Además, estas BlendShapes también se podrían animar, por lo que da una libertad muy amplia siempre que el trabajo manual encaje con el resultado a buscar. pág. 11

Sistema de evolución dinámico Metodología Se han aplicado ciertas metodologías con ayuda de Unity Engine y Blender: Se han seguido metodologías deductivas para encontrar los problemas principales, empezaba como una idea de modificar la edad, pero se llevó a un tema más concreto como el modificar el modelo para simular el crecimiento. Con técnicas de análisis se separó el problema en edad y hambre, para modificar 2 aspectos diferentes de la criatura, no solo por la edad. Con técnicas comparativa se dedujo que la modificación de rasgos faciales se podría llevar al resto de partes de una criatura y cambiando valores de escala generar un sistema de crecimiento. Por último, se aplica una modelación para dar forma a las BlendShapes en el programa de edición 3D, lo que lleva un poco de trabajo artístico. Se han escogido estas tecnologías debido a su buena fama, interfaz y el uso documentado y estudiado previamente por gente experta, con ello se ha conseguido llevar a cabo siguiendo un trabajo de tareas semanales los objetivos de ambas partes del proyecto por la parte de programación, estas tareas están redactadas en el siguiente apartado. pág. 12

Sistema de evolución dinámico Desarrollo del proyecto El videojuego Reverie Island se ha realizado gracias a 2 programadores, 3 artistas, 1 diseñador y 1 músico. Se llevó mediante tareas semanales que se detallarán más adelante. Roles de programación • Programación de gameplay: Criaturas, acciones principales. • Programación de IA: Movimiento y estado de ánimo de las criaturas. • Arreglo de bugs: Bugs cámara, paths… • Programación de interfaz: Interacción con los botones. Análisis • Plataforma de ejecución: PC, Windows. Esta plataforma permite una mayor libertad y no hay tantos límites gráficos. • Tipo de gráficos: 3D. Se buscó un arte original estilizado en 3D. • Periféricos de entrada: teclado/ratón. Por ahora no se plantean otros controles. • Herramientas de desarrollo: Unity engine. Es el motor más accesible y permite hace prototipos de una forma rápida y más sencilla. Realización de tareas Tareas de desarrollo del videojuego Se han llevado a cabo en forma de sprints semanales, serán enumeradas en orden cronológico sin especificar fechas, el cronograma de tareas del está adjuntado como anexo, en la hoja llamada “Sprints semanales” del archivo. No habrá una descripción detallada de cada tarea ya que no es el punto principal de esta investigación. • Cámara parametrizable • Zoom de la cámara • Generar Navigation mesh pág. 13

Sistema de evolución dinámico • Máquina de estados • Juego de la pelota • Ajustes de colisiones • Sistema de acariciar y comer • Sistema de expresiones • Implementar las animaciones • Añadir parámetro a las criaturas • Arreglar cualquier bug o mejoras al proyecto Como dato importante, se cambió el diseño inicial de la cámara del juego con la llegada del nuevo programador al equipo, quien ayudó a cambiar al sistema a Cinemachine, se produjeron algunos problemas que tuve que arreglar, pero es un sistema mucho más automatizado que ahorra tiempo de trabajo. Tareas de investigación Se han llevado de una forma un poco más desorganizada ya que no siguen el trabajo semanal del proyecto al ser algo separado. Se pueden dividir de la siguiente forma: • Estudio previo a la investigación Incluye el estudio de las distintas técnicas posibles para conseguir el objetivo de la investigación, se han tenido en cuenta técnicas de animación de huesos, nubes de puntos, shaders y modelado a mano, pero se llegó a la conclusión de aplicar la técnica de BlendShapes debido a su sencillez y forma sencilla de aplicar. • Edición en Blender Este programa permite el modelado, escultura, animación... de objetos 3D, en este caso se aplicó esta técnica siguiendo un tutorial (Glauz, 2016). pág. 14

Sistema de evolución dinámico Antes que nada, se decidió usar el modelo del pez, creado para el videojuego Reverie Island, ya que posee una buena distribución de polígonos y no daba mayores problemas, se importó sin animaciones ya que distraerían del objetivo principal de la investigación. Se hizo a mano yendo por partes, y siguiendo una nomenclatura como el vídeo a pesar de no ser necesaria, ya que no se usó el mismo proyecto como base en Unity y se programaron nuevos scripts para leer los datos de las BlendShapes. Se han generado las siguientes BlendShapes: ▪ Belly_Max ▪ Belly_Min ▪ Arm_Max ▪ Antenna_Max ▪ Fin_Max ▪ Tail_Max • Importar modelo a Unity Después de terminar el trabajo en Blender, se consigue un modelo con BlendShapes integradas en su MeshRenderer. Esto permite modificar esos valores entre 0 y 100 para que se apliquen los cambios generados en Blender. • Diseño del código Se decide optar por un diseño sencillo, separando entre 2 clases la criatura y los parámetros de tiempo. Creature.cs La criatura tiene 2 parámetros principales ▪ int hunger: Representa un parámetro de hambre ▪ int age: Representa un parámetro de edad pág. 15

Sistema de evolución dinámico Estos parámetros permiten la modificación de las BlendShapes en tiempo real, especialmente el hambre ya que es un parámetro que puede aumentar o disminuir, lo que afectará a la BlendShape del vientre, y la edad afecta al resto de BlendShapes. Se ha implementado código para que la criatura crezca de una forma más veloz, tan solo hay que pulsar el botón “Fast Grow” y los cambios ocurrirán de una forma mucho más directa. Además, se le vincula un botón para que pueda restaurar el hambre a su valor inicial sin ningún problema visual. Por último, puedes girar la criatura para verla desde distintos ángulos y apreciar mejor los cambios, simplemente girando con las teclas AWSD. TimeCount.cs Respecto a la clase que controla el tiempo, se puede observar cuanto tiempo ha pasado, los cambios siempre ocurrirán cada 5 segundos, se puede plantear a futuro dejarlo a decisión del usuario cuanto tiempo tarda en crecer la criatura. Por último, hay un botón de pause que permite parar el tiempo para observar los cambios de una forma relajada. • Documentación del proyecto Se ha optado por usar la herramienta Doxygen, ya que estoy familiarizado con ella y genera un formato web muy completo, además se ha creado un archivo MainPage.cs para Doxygen en el cual al abrir la web se puede acceder al Manual de usuario o a las clases directamente. pág. 16

Sistema de evolución dinámico Resultados y conclusiones Resultados En el proyecto generado se puede observar una criatura que cambia con el tiempo, dando la opción de que ese crecimiento sea más rápido. Aquí se puede ver el principio y el final del proceso de crecimiento Ver Figura 1 y Ver Figura 2. Figura 1 Criatura edad 1 año, hambre 1 Figura 2 Criatura edad 100 años, hambre 100 pág. 17

Sistema de evolución dinámico Este resultado ocurre de una forma natural cada 5 segundos, podría llevarse a cabo cada segundo, pero se decidió hacerlo así, con el botón de crecimiento rápido a parte, ya que encajaría mejor en un juego. Si alimentas a la criatura el vientre cambiará hacia el estado de estar lleno otra vez. Como único problema a destacar es que la textura se acaba deformando, por lo que un cambio demasiado brusco, se notaría que es algo no intencionado y daría problemas, por lo tanto, habría que plantear un cambio de textura si el departamento artístico lo permite. Por último, debería generar más scripts que ayuden a la organización de BlendShapes en grupos, ya que ayudaría a un desarrollo más rápido y cómodo si se quiere aplicar esta técnica, pero se ha generado una solución para funcionar en el caso de esta investigación. Conclusiones Sobre los objetivos cumplidos, se ha conseguido generar una deformación de la maya 3D equivalente a una evolución de la criatura, y este cambio ocurre en tiempo real, por lo que podría aplicarse a un videojuego sin grandes problemas. Se considera que el punto principal se ha conseguido de forma satisfactoria. Sin embargo, el resultado visual no es el ideal, ya que esta técnica necesita mucho cuidado artístico y podrían aplicarse diferentes texturas para adaptar la deformación generada, por lo que es un trabajo artístico complejo. No se pudo cumplir un objetivo principal: cambiar la textura en tiempo real. No es algo complicado si se aplica con una técnica de blending, pero debido al problema de buscar una textura adecuada y aplicar en un shader de Unity, no se pudo profundizar en ese apartado para llegar a un resultado adecuado, aunque no se descarta como trabajo futuro. Por último, sobre los objetivos secundarios tampoco hubo una implementación al videojuego final debido a la incompatibilidad con el diseño decidido y cambios que podrían llevar complicaciones en las colisiones o interacciones del juego. pág. 18

Sistema de evolución dinámico Trabajar otra criatura habría sido interesante pero la serpiente, de Reverie Island, debido a su baja poligonación no era un buen ejemplo por lo que se ha descartado para esta técnica, no es recomendable que se use en objetos low poly, ya que no haría una deformación natural. pág. 19

Sistema de evolución dinámico Post Mortem Parte de la investigación Sobre los objetivos sin cumplir se estudiaría una técnica de blending adecuada para cambiar el aspecto visual de la textura sobre el modelo, y que eso incluya cambios al normal map también ya que podría ser interesante para generar patrones o arrugas sobre la textura. Por otro lado, como línea a futuro, se investigaría el añadir geometría al modelo ya sea de una forma dinámica o cambiando partes del modelo, pero es algo que tiene mucha complejidad mientras el modelo sea 1 sola pieza, en cambio se podría estudiar en un modelo separado por partes bien diferenciadas y no conectadas. Parte del videojuego En el videojuego se han cumplido los objetivos principales, excepto un sistema de recompensas completo, por lo que ese es el primer objetivo en el trabajo a futuro. Seguidamente hay que pulir muchas mecánicas del juego, como la de comer ya que la criatura no se alinea correctamente antes de comer un alimento. Por último, el equipo se centrará en cumplir los objetivos secundarios y mejoras recibidas en el feedback recibido a lo largo del desarrollo del proyecto. Como línea a futuro habría que implementar un sistema de serialización para guardar todos los objetivos cumplidos por el jugador, estado de las criaturas y más datos importantes. pág. 20

Sistema de evolución dinámico Anexos Documentación del código Generada mediante Doxygen, por la parte de la investigación no se vio necesario generar diagramas UML complementarios debido a que no se hace uso de los principios de herencia de clases y no hay una gran complejidad en el código que se puede encontrar documentado a continuación. Por la parte del videojuego se hará una explicación de la estructura de clases que también se podrá ver dentro de los archivos generados por Doxygen, considero que no es un proyecto lo bastante complejo para organizarlo en diagramas. Documentación de la investigación Se puede encontrar en el siguiente enlace, abrir el archivo index.html: https://drive.google.com/file/d/1OeeJK7uGrxuQsN86XfVf5dlQNgF8WuSW/view?usp =sharing Documentación del videojuego Todo el código es de mi autoría excepto los scripts creados por Raúl López Martín: CinemachineManager, controladores de la música, controlador del cursor, controladores de los menús. Se decidió aplicar una máquina de estados en este proyecto porque es la mejor forma de organizar comportamientos complejos de una forma modular y separa el código de una forma limpia que lleva a menos problemas al cambiar código. También se aplica una factoría para generar esos estados, sin embargo, se podría mejorar guardando los estados en un “Diccionario” para no tener que generarlos cada vez. Se documentarán aquí todas las clases para que tengan constancia. Componentes En grandes rasgos, se puede dividir en 3 componentes principales: • Máquina de estados Representa la máquina de estados básica de una criatura y lo que define sus comportamientos pág. 21

Sistema de evolución dinámico • Juguetes Son objetos variados con propiedades físicas distintas que sirven para jugar o interactuar con las criaturas • Interfaz Incluye por un lado el menú radial de las criaturas para guiar al usuario y por otro el menú del juego. Clases A continuación, pondré todas las clases indicando su herencia junto a una breve explicación de cada una en caso de que no quede clara su función. Se abreviarán las herencias a MonoBehaviour como MB, la clase interna de Unity para agregar scripts a objetos de la escena. • Singleton: MB Clase que implementa una versión genérica del patrón Singleton, usado para el acceso de variables en el GameManager. • GameManager: Singleton Guarda eventos generales como salir del juego u otros datos. • CinemachineManager: MB Clase que maneja la cámara y todos sus eventos. • ToyBase: MB Estructura y propiedades generales de un juguete • Ball: ToyBase • Food: ToyBase • PetData: ScriptableObject • CameraData: ScriptableObject • LoadScene: MB • CursorManager: MB • AudioManager: MB pág. 22

Sistema de evolución dinámico • MusicChange: MB • MainMenu: MB Es el menú principal del juego al iniciarse el juego. • PauseMenu: MB Menú que aparece al pulsar escape y para el juego. • QuestMenu: MB Menú que activa o desactiva la bitácora y lleva el progreso de misiones. • CreatureRadialMenu: MB Menú que representa las acciones con las que se puede interactuar con una criatura. • ExpresionesOjos: MB Script que gestiona los cambios en los ojos de una criatura. • CreatureStateManager: MB Gestiona todas las variables de la criatura y las envía al estado activo. • CreatureStateFactory Construye los estados cuando son necesarios. • CreatureBaseState Clase base abstracta de todos los estados. • BallGameState: CreatureBaseState Estado que gestiona el juego de la pelota. • CleanThePetState: CreatureBaseState Estado que permite limpiar a la criatura. • EatState: CreatureBaseState Estado que permite alimentar a la criatura. • IdleState: CreatureBaseState Estado que gestiona la criatura y sus paths mientras no estás interactuando con ella. pág. 23

Sistema de evolución dinámico • PetModeState: CreatureBaseState Estado donde la criatura espera a que elijas una opción del menú radial mientras está en animación idle. • PetThePetState: CreatureBaseState Estado que permite acariciar a la criatura. La documentación de las fuentes completa se puede encontrar en este enlace abriendo index.html: https://drive.google.com/file/d/17Uk_tmNR1geiOlC5Wisjh90n7QrcoBW8/view?usp=s haring Requisitos mínimos del proyecto Juego desarrollado en Unity, se podrá abrir y generar una build funcional para Windows 10 según estos requisitos: • Sistema con Windows 10 o compatible con Unity • Procesador: Intel Core 2 Duo E4500 @ 2.2GHz or AMD Athlon 64 X2 5600+ @ 2.8 GHz. Memoria: 4 GB RAM. • Tarjeta gráfica: GeForce 240 GT or Radeon HD 6570 – 1024 MB (1 gig) • DirectX: Versión 9.0c. • Espacio: 5GB en disco para el videojuego, 2GB para la parte de investigación. • Versión 2021.3.11f1 del motor Unity para poder abrir el proyecto en el engine. pág. 24

Sistema de evolución dinámico Estructura del proyecto Estructura de la investigación La estructura general es la siguiente, no hay subcarpetas a destacar: Estructura del videojuego La estructura es la siguiente: pág. 25

Sistema de evolución dinámico Estructura carpeta de scripts Manual del proyecto Manual de la investigación Se puede encontrar dentro de la propia documentación de Doxygen en la página del index, incluido en el apartado “Documentación de la investigación”. Manual del videojuego Este es el manual del videojuego: https://docs.google.com/document/d/1f3e5_fD99c5- IkB1xeGgdito3FDRFPIj/edit?usp=sharing&ouid=112429158742493388817&rtpof=tru e&sd=true Archivos fuente Se pueden encontrar en el siguiente enlace de drive con permisos reservados a UDIT y alumnos. • Videojuego https://drive.google.com/file/d/1LyXJkVvkB9qztvV- X1OY9mP9DbJ_4UBu/view?usp=sharing • Investigación https://drive.google.com/file/d/1UDqtYZQmPYFyy- STV4PJ3Un8iTYfstqz/view?usp=sharing pág. 26

Sistema de evolución dinámico Binarios distribuibles Se pueden encontrar en los siguientes enlaces: • Videojuego https://irlaluen.itch.io/reverie-island • Investigación https://drive.google.com/file/d/1OftwSUz7GjHGY- a8bxDhCPVOqWDo1196/view?usp=sharing pág. 27

Sistema de evolución dinámico Referencias Frozen Mist. (15 de 2 de 2020). Capture & Morph Unity3D GameObject. Obtenido de https://www.youtube.com/watch?v=zjr2CRJ6K70 Glauz. (10 de 9 de 2016). Unity Character Customization with Blendshapes. Obtenido de https://www.youtube.com/watch?v=ypRhJAfJXAc&list=PLBk4jmgxHOA179JBhZjqDu 6Zxxz_8CmjC&index=17 Santesteban, I. (2017). Obtenido de https://addi.ehu.es: https://addi.ehu.es/bitstream/handle/10810/23787/TFG.IgorSantesteban.pdf?sequen ce=1&isAllowed=y Torres, M. S. (24 de 4 de 2015). Morph target animation: Prezi. Obtenido de Prezi: https://prezi.com/widtawy8rccb/morph-target-animation/ pág. 28