Unity Animaciones

De MediaWiki
Ir a la navegación Ir a la búsqueda

Introducción

  • Más información en:


  • En Unity podemos gestionar animaciones que vengan ya incorporadas a los modelos importados o bien podemos realizar nuestras 'propias animaciones'.
Cada una de las animaciones conforma lo que se denomina Clip en Unity.


  • Las animaciones propias son animaciones consistentes en modificar alguno de los parámetros que conformar el transform de cada GameObject.
Es decir podemos modificar:
  • Posición
  • Escala
  • Rotación
Estas modificaciones se producirán a lo largo de un período de tiempo y que conformará la animación.


Por ejemplo:
  • Podemos tener un soldado que siempre se esté moviendo de izquierda a derecha sin parar y que se desplace 10 metros.
  • O un pájaro que vuele por la pantalla siguiendo una ruta 'predefinida' y que se repita continuamente.


  • En cuanto a las animaciones ya incorporadas a los modelos, estas animaciones están asociadas a un nombre (por ejemplo, andar, correr,...)
Unity permite crear una máquina de estados en las que cada animación tiene lugar en función del estado en que se encuentre el GameObject. Este pasará de un estado a otro en función de los valores que puedan tomar variables definidas por nosotros.
Unity3d animacion 0.jpg





Importando modelos con animaciones

  • Muchas de las animaciones que vamos a poder utilizar son aquellas en las que el modelo tiene asociado un esqueleto o bones.
Unity3d animacion 0A.jpg
Como vemos en la imagen, la figura 3D tiene asociado un RIG.
Básicamente consiste en asociar a un modelo 3D un conjunto de huesos los cuales están asociados a la figura, de tal forma que al mover dichos huesos, movemos las partes de la figura 3D asociada.
Este tipo de animaciones se denominan Humanoid en Unity y están asociados a un Avatar.
Los modelos que vienen con este tipo de animaciones tienen una pose en T.
Suelen ser todos bípedos y con unas características comunes para que:
  • Los esqueletos y movimientos asociados puedan ser aplicados a cualquier figura 3D con esta forma (retargeting)
  • Permite realizar Inverse Kinematic, es decir, indicar un punto determinado del espacio y hacer que los huesos del esqueleto se muevan correctamente para llegar a ese punto.
Unity3d animacion 0B.jpg



  • Podemos disponer de modelos 3D que no se adaptan a este tipo y que Unity denomina Generic:
Unity3d animacion 0C.jpg
En la imagen tenemos una figura 3D que no responde al tipo de 'Humanoide'.



  • Uno de los sitios que actualmente es gratuito y permite 'asociar' animaciones a modelos 3D es https://www.mixamo.com.
Una vez registrados accederemos a su página que actualmente tiene este aspecto:


  • Indicar que tanto en animaciones como en modelos, podemos filtrar los resultados buscando por palabras claves.
  • Si nos vale alguno de los modelos, veremos a continuación como hacer uso de ellos en Unity.
En el ejemplo siguiente partimos que no nos vale ninguno de los modelos y que utilizamos otro descargado o diseñado por nosotros mismos.
Recordar que esto solo vale para animaciones de tipo 'humanoide' como ya explicamos anteriormente.
  • Actualmente se puede descargar la aplicación Fuse de Adobe que permite diseñar nuestros avatares de forma totalmente personalizable.
Unity3d animacion 14.jpg





  • Ahora los importamos a Unity:



  • En este punto ya disponemos de 4 modelos con 4 animaciones (Clips).
Unity3d animacion 19A3.jpg


Fijarse que solo en una de ellas se previsualiza el modelo.
Si desplegáis el contenido de cada modelo (presionando la flecha hacia la derecha en cada uno) podéis ver como en todos ellos disponemos de un 'Clip' que viene a ser la animación asociada al mismo.
Unity3d animacion 19A4B.jpg

y un avatar.

  • Podemos comprobar como en Zombie Idle se encuentra toda la información del modelo (texturas, materiales, animación, avatar y mesh).
En el resto de animaciones solo tenemos el avatar y la animación ya que las hemos descargado sin el Skin.




  • El siguiente paso es configurar los modelos importados con las animaciones para indicar que son animaciones de tipo 'Humanoide'.
Para ello es necesario tener al menos en Avatar.
En el avatar es donde se guarda la información del esqueleto y las partes en las que se divide el modelo para poder realizar la animación. Estas partes son la cabeza, columna, brazos, piernas, manos,...



  • Indicar que los nombres de los Clips cuando lo descargamos de la web de Mixamo son siembre mixamo.com.
Aunque en el ejemplo que viene a continuación no están cambiados, para realizar operaciones posteriores va a ser necesario que tengan un nombre significativo.
Para cambiar el nombre del Clip, debemos de seleccionar el Modelo en la ventana Project y sobre la ventana Inspector => Animation, cambiar el nombre:
Unity3d animacion 62.jpg



Gestionando las animaciones. Animator Controller


Creando un Animator Controller. Animación inicial

  • En este punto ya tenemos las diferentes animaciones (clips) añadidas al proyecto de Unity.
Ahora es necesario gestionar dichas animaciones. Debemos de tener algún mecanismo que nos permite controlar cuando la figura 3D está en una animación o en otra.
Cuando pulsa una tecla quiero que pase de Idle a Walk.
Cuando presiono el botón de disparo quiero un Attack.
  • Todo esto se controla con una máquina de estado a a través de un Animator Controller de Unity.



  • Al pulsar dos veces sobre el AnimationController (darle un nombre adecuado), accedemos a la máquina de estados:



Reutilizando las animaciones sobre otros modelos

  • Imaginemos que estas mismas animaciones las queremos utilizar con otros 'modelos', en este caso, de tipo 'Humanoide'.



Caso especial: Modelo con un RIG diferente

  • Imaginemos que tenemos descargadas todas las animaciones anteriores y queremos aplicarlas a otro modelo diferente.
Veremos a continuación como hacerlo, pero para que funcione necesitamos que el modelo nuevo tenga 'las mismas partes' que el modelo original.
Mirar el siguiente modelo de Mixamo:
Unity3d animacion 63.jpg
¿ Notáis que falta algo ? :)
  • Realizar los siguientes pasos:
  • Descargar dicho modelo (sin animaciones asocidas), en posición T.
  • Importarlo a Unity.
  • Ir a la sección Model y desmarcar las opciones indicadas anteriormente (recordar presionar el botón Apply).
  • Si no veis correctamente el modelo recordar extraer los materiales y texturas en la sección 'Materials'.
  • Ir a la sección RIG e indicar que el modelo es de tipo Humanoid y el Avatar dejar la opción Create from this model. Os aparecerá un error al presionar el botón Apply.
Ese error indica que falta el brazo derecho y que no tiene transform asociado.
Unity3d animacion 64.jpg
  • Lo que hacen los avatares es estar divididos en partes (manos, pies, tronco cabeza,...) y asociar a cada parte un 'transform' el cual puede ser modificado para 'producir las animaciones'.
En este caso, el avatar no tiene el brazo derecho (lógico, para qué lo necesita el zombie :) )
  • Para solucionar vamos a modificar el avatar y decirle que haga uso de transforms en esas partes, pero que no van a 'dibujar' nada.





Analizando la máquina de estados

  • Más información:


  • Como ya comentamos anteriormente el Animator Controller permite tener una máquina de estados. En cada estado vamos a poder 'asociar' una animación y vamos a poder pasar de un estado a otro en base a diferentes tipos de condiciones.
Esas condiciones las vamos a poder modificar por medio de scripts.


  • Imaginemos un caso típico en el que en base a la vida que le queda al zombie, este se muere.
Para ello vamos a necesitar un parámetro vida o bien una variable de tipo boolean que indique cuando el zombie ha muerto.
Vamos a optar por la variable de tipo boolean.
Podríamos optar por el parámetro de vida si por ejemplo, al tener diferentes valores, quisiéramos diferentes animaciones. Imaginar que en caso de que le quede 5 de vida, pasaríamos a que el zombie se arrastrara. Y en caso de llegar a 0 moriría.


  • Estando en el Animator Controller del Zombie podemos ver los tipos de parámetros que podemos crear:
Unity3d animacion 38.jpg
  • Float: Una variable de tipo Flotante.
  • Int: Una variable de tipo Entero.
  • Bool: Una variable de tipo Booleana.
  • Trigger: Viene a ser una variable de tipo Booleana (admite valores true/false) con la diferencia que una vez la transición se ha producido su valor vuelve a valer false automáticamente.
Un ejemplo de uso de este tipo de variables puede ser cuando estamos disparando un arma y se acaba la munición. En ese momento debemos de pasar a la animación de cargar el arma (sería poniendo a true una variable de este tipo) e inmediatamente después continuaríamos con la animación de disparar. Al pasar a la animación de disparar, la variable Trigger ya valdría false otra vez.


  • Veamos un ejemplo práctico.
La pregunta que te estás haciendo es, ¿ por qué hago uso de una variable de tipo Trigger y no de una de tipo Boolean ?
Haz la prueba y comprueba lo que pasa.
El problema estriba en que AnyState es cualquier estado aún sin acabar de ejecutarse la animación.
Si haces uso de una variable booleana, el valor de dicha variable seguirá valiendo 'true' hasta que cambies nuevamente a 'false', por lo tanto, si hacemos la prueba gráficamente veremos que se ejecuta continuamente la animación de Zombie Death sin que acabe nunca.
Esto se puede solucionar a nivel de programación, cambiando el valor de dicha variable a false inmediatamente después de ponerla a true (veremos como hacerlo). Pero esto es lo que hace la variable de tipo Trigger. Se pone a false inmediatamente después de true.


  • Vamos a realizar ahora otro caso práctico que va a consistir en añadir un parámetro velocidad, para que en función del valor del parámetro cambie de estado de Zombie_Parado a Zombie_Walk y viceversa.



Modificando los parámetros por medio de scripts

  • Antes de entrar en los scripts vamos a realizar unas pequeñas modificaciones al ejemplo.
Vamos a dejar a los dos zombies sin rotar y cambiaremos la cámara de posición para que se vean más lejanos. Al hacerlo los zombies aparecerán de espaldas. Rotamos la cámara de sitio para que se vean por delante.
Aumentaremos la escala del plano para que tengan más superficie por donde 'andar'.
Unity3d animacion 53.jpg



  • Como queremos que desde la animación de 'parado' pase a la animación de 'andar' sin que haya una transición, no chequeamos el parámetro Has Exit Time de la transición:




  • Por medio de scripts vamos a poder acceder a los valores de los parámetros definidos en el AnimatorController.
Unity3d animacion 51.jpg
En la imagen hemos creado un script de nombre ControlEstadoZombie.
Recordar colocarlo dentro de una carpeta de nombre Scripts y dentro de esta organizarlo como mejor creáis.
Unity3d animacion 52.jpg


  • Ahora editamos el código del script.
 1 using UnityEngine;
 2 
 3 public class ControlEstadoZombie : MonoBehaviour {
 4 
 5     [SerializeField]
 6     private float velocidadMaxima;
 7     [SerializeField]
 8     private int vida;
 9 
10     private float velocidadActual = 0f;
11     private Animator animator;
12 
13     // Se ejecuta cuando hacemos un reset del script desde la ventana Inspector de Unity
14     void Reset()
15     {
16         velocidadMaxima = 2;
17         vida = 5;
18         velocidadActual = 0;
19     }
20 
21 
22     // Use this for initialization
23     void Start () {
24         animator = GetComponent<Animator>();
25     }
26 
27     // Update is called once per frame
28     void Update () {
29 
30     }
31 }
  • Líneas 11 y 24: Estas líneas definen un objeto de la clase Animator (de nombre animator) y en la línea 24 obtenemos el objeto Animator que tiene asociado el GameObject en el Inspector y se lo asignamos a la variable.
  • Resto de líneas las explicaremos más adelante.


Como a nosotros nos interesa acceder a los parámetros creados, podemos acceder con:


Disponemos de los correspondientes métodos GetFloat, GetBool, GetInteger para obtener los valores actuales de los parámetros.


  • Lo que queremos hacer es que cuando se produzca un evento (una colisión, una pulsación del ratón, que el zombie detecte nuestra presencia,....) cambiemos el estado de parado a moviéndose.
Vamos a hacerlo con la tecla W (podéis hacerlo de cualquier otra forma).
1     void Update() {
2         if (Input.GetKeyDown(KeyCode.W)){
3 
4             animator.SetFloat("velocidad", 1);
5         }else if (Input.GetKeyDown(KeyCode.S))
6         {
7             animator.SetFloat("velocidad", 0);
8         }
9     }
  • Liñas 4 y 7: Cambiamos el valor del parámetro 'velocidad' en función de si pulsamos la tecla W o la tecla S
  • Si ejecutamos este código vemos que funciona, pero que el zombie no se mueve debido a que no estamos modificando su posición como ya vimos en esta Wiki.
Modificamos el código para hacerlo:
 1     void Update() {
 2         transform.Translate(transform.forward * velocidadActual * Time.deltaTime);
 3         if (Input.GetKeyDown(KeyCode.W)){
 4             animator.SetFloat("velocidad", 1);
 5             velocidadActual = 1;
 6         }else if (Input.GetKeyDown(KeyCode.S))
 7         {
 8             animator.SetFloat("velocidad", 0);
 9             velocidadActual = 0;
10         }
11     }
12 
13     // Update is called once per frame
14     void Update() {
15  
16         transform.Translate(transform.forward * velocidadActual * Time.deltaTime);
17  
18     }
Unity3d animacion 53.jpg
El zombie se mueve...


  • Ahora vamos a complicarlo un poco y vamos a hacer que el zombie tenga diferentes velocidades, es decir, que se pueda mover más rápido.
Podemos hacerlo cambiando el código:
 1     void Update() {
 2         transform.Translate(transform.forward * velocidadActual * Time.deltaTime);
 3         if (Input.GetKeyDown(KeyCode.W) && velocidad<5){
 4             animator.SetFloat("velocidad", 1);
 5             velocidadActual++;
 6         }else if (Input.GetKeyDown(KeyCode.S) && velocidad > 0)
 7         {
 8             animator.SetFloat("velocidad", 0);
 9             velocidadActual--;
10         }
11     }


Pero para hacerlo 'mas bonito' vamos a emplear un control gráfico HorizontalSlider.
Para ello creamos un nuevo método OnGUI:
 1 public class ControlEstadoZombie : MonoBehaviour {
 2 
 3     [SerializeField]
 4     private float velocidadMaxima;
 5     [SerializeField]
 6     private int vida;
 7 
 8     private float velocidadActual = 0f;
 9     private Animator animator;
10     private float m_MySliderValue;
11 
12     void Reset()
13     {
14         velocidadMaxima = 2;
15         vida = 5;
16         velocidadActual = 0;
17     }
18 
19     // Use this for initialization
20     void Start () {
21         animator = GetComponent<Animator>();
22     }
23 
24     void OnGUI()
25     {
26         GUI.Label(new Rect(0, 25, 40, 60), "Speed");
27 
28         // Devuelve un float en un rango entre 0.0f y velocidadMaxima
29         m_MySliderValue = GUI.HorizontalSlider(new Rect(45, 25, 200, 60), m_MySliderValue, 0.0f, velocidadMaxima);
30 
31         velocidadActual = m_MySliderValue;
32         animator.SetFloat("velocidad", velocidadActual);
33     }
34 
35     // Update is called once per frame
36     void Update() {
37 
38         transform.Translate(transform.forward * velocidadActual * Time.deltaTime);
39 
40     }
41 
42 }
  • Línea 4: Esta variable va a indicar la velocidad máxima a la que vamos a poder mover el zombie.
  • Líneas 24-33: Dibuja el Slider y en función de su valor ajusta la velocidad del zombie
  • Línea 16: Dibuja un label con texto speed.
  • Línea 19: Dibuja un Horizontal Slider con un rango entre 0.0f y velocidadMaxima. Devuelve el valor seleccionado gráficamente.
  • Línea 31: Asignamos la velocidad para la función translate del transform.
  • Línea 32: Cambiamos la velocidad del parámetro. No importa su valor, solo si es mayor que 0.1f


Unity3d animacion 58.jpg
  • Ahora el problema lo tenemos en que la velocidad del zombie no se corresponde con la 'velocidad del movimiento'. Gráficamente se mueve muy lento cuando aceleramos.
Para solucionarlo podemos hacer uso de la propiedad Speed
Unity3d animacion 59.jpg
Lo que queremos es que el valor de esa propiedad cambie con la velocidad.
Como a nivel de programación disponemos del objeto 'animator' que representa toda la máquina de estados, podemos modificar su valor con el siguiente código:
 1     void OnGUI()
 2     {
 3         GUI.Label(new Rect(0, 25, 40, 60), "Speed");
 4 
 5         // Devuelve un float en un rango entre 0.0f y velocidadMaxima
 6         m_MySliderValue = GUI.HorizontalSlider(new Rect(45, 25, 200, 60), m_MySliderValue, 0.0f, velocidadMaxima);
 7 
 8         velocidadActual = m_MySliderValue;
 9         animator.SetFloat("velocidad", velocidadActual);
10         animator.speed = (m_MySliderValue == 0) ? 1 : m_MySliderValue;  // Al iniciar la ejecución el Slider vale 0. La velocidad de la animación no puede valer 0 ya que no se ejecutaría y por lo tanto no cambiaría de estado.
11     }
Si ejecutáis el juego podéis comprobar como al aumentar la velocidad aumenta la velocidad de la animación.


  • El siguiente paso a programar podría ser cuando el zombie muere.
Normalmente tendréis una determinada vida y al acabar con ella el zombie (o el protagonista) deben morir.
Morir en el caso de los enemigos suele llevar el que desaparezca.
Vamos a programar que el zombie tenga una vida. Al pulsar la tecla 'M' vamos a quitar una vida al zombie. Al llegar a cero vamos a hacer que muera.
 1    void OnGUI()
 2     {
 3         if (vida > 0)
 4         {
 5             GUI.Label(new Rect(0, 25, 40, 60), "Speed");
 6 
 7             // Devuelve un float en un rango entre 0.0f y velocidadMaxima
 8             m_MySliderValue = GUI.HorizontalSlider(new Rect(45, 25, 200, 60), m_MySliderValue, 0.0f, velocidadMaxima);
 9 
10             velocidadActual = m_MySliderValue;
11             animator.SetFloat("velocidad", velocidadActual);
12             animator.speed = (m_MySliderValue == 0) ? 1 : m_MySliderValue;  // Al iniciar la ejecución el Slider vale 0. La velocidad de la animación no puede valer 0 ya que no se ejecutaría y por lo tanto no cambiaría de estado.
13         }
14     }
15 
16     // Update is called once per frame
17     void Update() {
18         if (vida > 0)
19         {
20             transform.Translate(transform.forward * velocidadActual * Time.deltaTime);
21         }
22 
23         /*
24         if (Input.GetKeyDown(KeyCode.W)){
25             animator.SetFloat("velocidad", 1);
26             velocidadActual = 1;
27         }else if (Input.GetKeyDown(KeyCode.S))
28         {
29             animator.SetFloat("velocidad", 0);
30             velocidadActual = 0;
31         }
32         */
33 
34         if (Input.GetKeyDown(KeyCode.M))   
35         {
36             vida--;
37             Debug.Log("Vida" + vida);
38             if (vida == 0)   // Podemos usar == ya que es de tipo int
39             {
40                 animator.speed = 1;     
41                 animator.SetTrigger("muerto");
42             }
43         }
44     }
45 }
Si ejecutáis el código y presionáis la tecla M cinco veces, el zombie morirá.
  • Línea 43: Fijarse que tenemos que volver a poner la velocidad a su valor por defecto, ya que sino, cuando inicie la animación del Zombie_Death lo haría a la velocidad establecida cuando el zombie andaba.


Unity3d animacion 60.jpg


  • Ahora solo queda hacer que el zombie desaparezca.
Para ello hay que hacer uso del método GetCurrentAnimatorStateInfo(int layerIndex); el cual devuelve un objeto de la clase AnimatorStateInfo y que nos da información sobre la animación en curso.
  • Una de las propiedades es normalizedTime el cual devuelve un valor entre 0-1 indicando cuando llega a 1 que la animación terminó.
  • Uno de sus métodos es isName(String Nombre_animación) el cual devuelve un true/false si el animator está ejecutando la animación indicada en el parámetro.


Para destruir el zombie tengo que preguntar si estoy en la animación 'Zombie_Death' y se ha acabado de ejecutar. Eso traducido a programación es:
 1     // Update is called once per frame
 2     void Update() {
 3         if (vida > 0)
 4         {
 5             transform.Translate(transform.forward * velocidadActual * Time.deltaTime);
 6         }
 7 
 8         /*
 9         if (Input.GetKeyDown(KeyCode.W)){
10             animator.SetFloat("velocidad", 1);
11             velocidadActual = 1;
12         }else if (Input.GetKeyDown(KeyCode.S))
13         {
14             animator.SetFloat("velocidad", 0);
15             velocidadActual = 0;
16         }
17         */
18 
19         if (Input.GetKeyDown(KeyCode.M))   
20         {
21             vida--;
22             Debug.Log("Vida" + vida);
23             if (vida == 0)   // Podemos usar == ya que es de tipo int
24             {
25                 animator.speed = 1;     
26                 animator.SetTrigger("muerto");
27             }
28         }
29 
30         if (animator.GetCurrentAnimatorStateInfo(0).IsName("Zombie_Death") && animator.GetCurrentAnimatorStateInfo(0).normalizedTime>=1f)
31         {
32             Destroy(gameObject);
33         }
34     }


Unity3d animacion 61.jpg



  • Métodos útiles:
  • animator.GetCurrentAnimatorStateInfo(0).IsName("Zombie_Walk"): Devuelve true si el zombie se encuentra en la animación Zombie_Walk.
El (0) hace referencia a las capas, las cuales se usan para animar de forma diferente a diferentes partes del cuerpo.


Opciones no vistas



Gestionando las animaciones. Animator Override Controller


  • Este control permite tener un Animator Controller basado en otro ya hecho, pero permitiendo cambiar las animaciones asociadas a cada uno de los estados.
Tendrá las mismas condiciones y variables que el Animator Controller del que se basa.
  • Veamos un ejemplo:




Creando animaciones propias

  • En Unity es posible crear nuestras propias animaciones, es decir, crear nuestros propios clips.
  • El proceso sería el siguiente:
  • Añadir a lo que va a ser el Clip aquellos GameObjects que queramos animar.
  • Dentro de cada GameObject añadimos aquellas propiedades que van sufrir modificaciones durante la animación.
Podemos modificar el componente Transform, el componente Mesh Renderer, Mesh Collider, RigidBody e incluso activar o desactivar scripts todo de forma dinámica.
  • Establecemos el tiempo que va a dura el Clip.
  • Iniciamos la grabación del Clip y establecemos 'puntos de referencia'. En cada uno de esos puntos modificamos alguno de los valores de alguno de los componentes indicados anteriormente. Unity ya se encarga de, por medio de la interpolación' modificar los valores de los componentes (por ejemplo la velocidad, posición, rotación,...) para llegar al punto destino con los valores indicados por el usuario.



  • Ahora llega el momento de grabar la animación.


  • Si ejecutamos el juego podemos ver como la animación se pone en marcha.
Esto es así ya que se ha creado un AnimatorController y que ha sido asociado al GameObject puerta al crear la animación.
Podemos tratarla como cualquier otra animación como hicimos en el punto anterior.
Unity3d animac propia 14.jpg


  • Vamos a realizar una modificación para hacer que la escala de la puerta decrezca y que así no 'salga' por la parte de arriba.
Normalmente esto no sería necesario ya que si el juego es en primera persona, la puerta no se abriría hasta estar cerca de la misma y por tanto no veríamos la parte de arriba.


  • Ahora vamos a hacer que la puerta tenga un RigidBody para hacer que los personajes tropiecen con la puerta.





Modificando el orden de los componentes

  • Supongamos que tenemos un script que realiza una rotación sobre un GameObject.
Además, sobre el mismo GameObject tenemos una animación la cual también modifica la rotación del mismo GameObject.
  • En este caso tenemos un problema, ya que la animación siempre va a partir de la rotación inicial del GameObject antes de ejecutar la animación.
Recordar que todos los GameObjects se crean en el punto (0,0,0) y sin rotación y que después, en nuestro script, los trasladamos - rotamos a la posición que queramos.
Si nuestro GameObject está rotado y situado en otro punto inicialmente, la animación se aplicará sobre estos valores.
  • Por lo tanto, cuando aplicamos la animación, esta, parte de la posición inicial del GameObject y de su rotación.
Si nuestro script aplica una rotación 'después' de la animación, cuando vuelva a ejecutar la siguiente parte de la animación, 'borrará' la rotación realizada en el script.


  • Para evitarlo podemos:
  • Crear un GameObject vacío y hacer que el modelo sea 'hijo' de este GameObject, asociando nuestro script al GameObject vacío.
  • Cambiar el orden de los componentes en la Inspector Window y hacer que el script se ejecute antes, por lo que primero realizará nuestra rotación y después la rotación de la animación.


  • Veamos un ejemplo con un avión en el hemos creado una rotación que simula el movimiento de 'balanceo' del mismo en el aire (rotando el avión en el eje Z a izquierda-derecha).






-- Ángel D. Fernández González -- (2018).