Buenas a todos, les vengo a hablar del Producto Vectorial o el Producto Cruz en Unity 3D, tal vez en otros motores de VideoJuegos sea lo mismo, pero ahora estoy desarrollando un juego en Unity 3D y desconozco por el momento otros motores como Unreal Engine, etc. Auque aunque estube mirando un poco de Unreal Engine y es muy interesante, pero el que mucho agarra poco aprieta, así que por el momento Unity 3D.
Resulta que necesito para mi juego un personaje que camine por las paredes, luego de buscar y buscar por google me encontré con código para hacer esto, yo tengo experiencia en juegos 2D, pero en 3D soy algo muy nuevo, es lo mismo pero con el eje Z de profundidad, luego de inspeccionar el código, me encontré con muchas cosas nuevas y interesantes que me llevo a estudiar algo de Trigonometría y Vectores, y para el personaje pueda "caminar por una pared", se necesita que este rote y de mas cosas, para que quede paralelo con la pared, voy a explicarles de la forma mas pedagógica posible, como entender esto, les recuerdo que deben tener unos conocimientos medio de programacion o de unity 3D, o que hayan ya toqueteado algo del programa, y sepan que son los ejes (x, y, z), creo que si ya llevas haciendo unos juegos en unity este te sera muy bueno, y para los amantes de el saber como funciona todo milimetricamente, y con detalles y sepas algo de lo que hace un Script o codigo de c# y lenguajes similares.
Tube la necesidad de hacer este tutorial o guia, porque en realidad no encontraba mucha información en los foros de unity 3D, y si los había eran demaciados complejo entenderlo y en ingles, para los que recién empiezan en este mundo de los juegos 3D les resulta muy difícil empezar y esto puede lograr que tiren la toalla al estancarse. Les recuerdo que esta guia esta pensada para que lo entiendas de la forma como se lo explicarías a un niño, de forma suave y entendible, si es que te interesa y creo que va a hacer necesario, que leas una guia de vectores que me ayudo bastante, es información muy importante, pero es para programar en ensamblador, pero las explicaciones sirven para Juegos 3D la pagina es: Click Aqui y tambien pueden Visitar el tutorial de Unity 3D Vector maths.
Esta guia en su mayoría tendrá Imagenes para explicarle en forma gráfica del como es, y también va a estar el codigo en C#, que lo que hace es rotar un cubo en relación con otro cubo, ustedes pueden remplazar este cubo por una pared o una pendiente, o otras cosas. Pero esto es como es y como funciona Vector3.Cross(Vector, Vector) y Quaternion.LookRotation(Vector, Vector), ustedes lo pueden usar para otras cosas modificandolo un poco, pero para esta guia solo se dedicara como rotar cosas, con Quaternion, Lerp, LookRotation. El blog esta abierto critica constructiva, ya que es mi primer tutorial, y tampoco me considero por el momento un experto en Matemáticas y Juegos 3D, esto se logra con practica y mucha paciencia y estudio, por el momento estoy empezando en este mundo del 3D, bueno empecemos. Antes de empezar es importante que sepas que es un Vector, va a servir tanto para 2D como para 3D.
Vectores
Un vector es una dirección, con magnitud, que empieza en el origen y termina en un punto en el espacio, no es una posición. En Unity veras en el código algo como Vector3(0, 0, 0), que significa que es un vector en 3 dimenciones Vector3(x, y, z). En la siguiente imagen es un Vector de 2D, con las coordenadas X e Y, y si quieres, imaginar el valor Z de profundidad, es apuntando hacia atrás, pero el valor de z = 0 (1, 1, 0) , mientras, que los demás es de valor de x = 1 (1, 0, 0) valor de y = (0, 1, 0). La unidad de medida es unitario osea 1 porque esta normalizado, dividido por su longitud, esto permite por ejemplo, mas adelante mover un objeto, a una posición determinada, a una velocidad, que puede cambiar o no, puede moverse muy lento o muy rápido. Mas adelante haré un tutorial sobre esto, ya que es importante también.
Coordenadas globales en Unity 3D
Antes de Empezar debemos saber que son las coordenadas globales en Unity 3D, tal vez suene algo muy obvio pero mucha gente no se da cuenta, es la siguiente imagen donde se ubica en la parte superior derecha en la interfaz de Unity.
Coordenadas locales en las entidades.
Coordenadas locales, con el botón este podemos habilitar y deshabilitar las coordenadas locales a globales, los ejes x, y, z cambiaran de las coordenadas locales del objeto a las coordenadas globales, y viceversa, en las imagenes estará activado a local.
Ahora ya sabiendo esto vamos aprender como orientarnos en las entidades en el mundo en el código.
Producto Cruz
Veamos que es el producto cruz o producto vectorial, por ejemplo tenemos dos vectores apuntando, a diferentes direcciones, el producto de estos dos vectores nos dará otro Vector, que será perpendicular, a los otros dos, si el ángulo entre ellos es 180, 0, nos dará 0. Si el ángulo entre ellos es de 90 grados, el resultado será 1.
Lo que vamos a analizar es el Producto Cruz o Producto Vectorial. En el codigo de c# siguiente:
using UnityEngine;
using System.Collections;
public class LookQuaternio : MonoBehaviour {
public Transform target;
// Use this for initialization
private bool go = true;
void Start () {
Debug.Log("Transform right: " + transform.right);
//Debug.Log("Transform forward: " + transform.forward);
Debug.Log("target transform right: " + target.right);
}
public IEnumerator rotar(Quaternion orgRot, Quaternion rotation)
{
for (float t = 0.0f; t < 1.0f; )
{
t +=Time.deltaTime;
transform.rotation = Quaternion.Slerp(orgRot, rotation, t);
yield return null;
}
}
// Update is called once per frame
void Update () {
if (Input.GetButton("Fire1"))
{
if (go == false) return;
go = false;
Vector3 myForward = Vector3.Cross(transform.right, target.right);
Debug.Log("myForward Cross: " + myForward);
// Debug.Log("myForward Cross" + myForward);
Quaternion orgRot = transform.rotation;
Debug.Log("orgRot: " + orgRot);
Quaternion rotation = Quaternion.LookRotation(myForward, target.right);
Debug.Log("rotation: " + rotation);
StartCoroutine(rotar(orgRot, rotation));
} else {
if (Input.GetButton("Fire2"))
{
go = true;
}
}
}
}
Aquí entramos en materia, vemos algo nuevo, si es que usaste otra forma de crear juegos o sos totalmente nuevo en el desarrollo de juegos en Unity o También sirve para otros motores no limitarnos a solo uno.
Vector3 myForward = Vector3.Cross(transform.right, target.right);
Se los gráfico en la siguiente imagen:
Vamos a orientarnos en los ejes, vemos el cubo Rosa, el eje X de dicho cubo, corresponde a target.right en el código, en el Log de Unity podemos ver que es (1.0, 0.0, 0.0), notar que coincide a las coordenadas globales de Unity. Pero ahora centremonos en el cubo Violeta, la cual es nuestro objeto principal, el cual tiene el código de arriba. Podemos, ver que nos referimos al igual que el cubo rosa, al eje X, transform.right, pero en este caso el eje X, esta apuntando a Z, de las coordenadas globales. Por eso en el Log Console podemos ver Transform right (0.0, 0.0, 1.0). Bien ya sabemos, donde estamos parados y orientados, y podremos movernos ya al saber, que son nuestros ejes.
Ahora veremos el resultado del producto vectorial y como aplicarlo:
Vector3 myForward = Vector3.Cross(transform.right, target.right)
Para entender esto debemos aplicar una técnica para ayudarnos, es la regla de la mano izquierda, pero yo también la llamaría de la mano derecha, ya que con los ejemplos usaremos las dos manos. La siguiente imagen muestra la mano derecha, y como ayudarnos a resolver el producto vectorial o producto cruz.
Bueno explico la imagen, podemos ver que el dedo pulgar, apunta o esta orientado, al target, osea nuestro objetivo, el cubo Rosa, que es Vector tarjet.right en este caso del dedo pulgar es (1, 0, 0), vector.cross("cubo violeta", "cubo rosa"), no poner así en el código porque de seguro les dará error, es solo explicativo. Ahora pasemos al cubo violeta, vemos que el eje X, del cubo, esta apuntando, al eje Z, de las coordenadas globales de Unity, al indicar target.right, y por esta razón vale, (0, 0, 1), ya veremos el dedo medio. Bueno ya tenemos dos vectores uno para el violeta que es nuestro, podríamos decir, "personaje", y el otro puede ser que sea una "pared", bueno ya tenemos un Vector del cubo Rosa, target.right (1, 0, 0), y otro Vector del cubo violeta, transform.right (0, 0, 1), ahora si juntamos, estos vectores, como en la imagen, obtenemos otro Vector el cual es el producto Vectorial o producto Cruz, el resultado, el cual corresponde, al dedo medio, y su valor es (0, 1, 0), en la imagen lo podemos ver en el Log, myForward (0.0, 1.0, 0.0). Listo!!
Rotando con Producto Cruz
Bueno ahora que ya tenemos el producto Cruz, podemos seguir con nuestra explicacion del codigo, En la siguiente imagen vemos como va rotar o mirar el cubo violeta con relación al objeto target o cubo rosa que le indicamos el código, recordar que el eje Y (verde) es el producto Cruz o resultado de aplicar Vector3 myForward = Vector3.Cross(transform.right, target.right), Bueno de la manera que va a rotar es:
Quaternion rotation = Quaternion.LookRotation(myForward, target.right)
Bueno podemos ver en la imagen el sentido de la rotación, de Quaternio.LookRotation(myforward, target.right), aquí lo que debemos hacer es juntar los dos vectores, tenemos el vector, del producto vectorial,
Vector3 myForward = Vector3.Cross(transform.right, target.right)
, el cual es en este caso (0, 1, 0 ), el eje Y positivo, y también debemos juntar, el otro vector, target.right, de nuestro cubo Rosa, se puede apreciar que el giro va hacer del eje X al eje Y, sin pasar por otros ejes, pero va a ver casos, en el que la rotación, girara, aplicando a los 3 ejes. También al ser la dirección del eje Z el que nos interesa alinear este pasara a ocupar la posición del producto vectorial o cross, donde antes estaba el eje Y ahora estará el eje Z. Aquí es un poco mas complicado predecirlo pero se puede, en la siguiente imagen veremos una tabla que indica, las rotación y con diferentes ejes, cambiaremos la dirección, para ver diferentes rotaciones, les ajuntare el proyecto de Unity, para que puedan practicar, o talvez decidan usar su código o su juego.
Finalmente lo que hace que nuestro cubo rote es el siguiente código, que rota desde una dirección a otra que le indiquemos,
Quaternion.Slerp(orgRot, rotation, t)
, donde el primer parametro es nuestra rotación actual, y el otro parametro es la rotación hacia donde y en que sentido queremos rotar, que es en sentido de nuestro target que es el cubo Rosa, donde hemos aplicado el producto vectorial, y el tercer parametro es el tiempo:
public IEnumerator rotar(Quaternion orgRot, Quaternion rotation)
{
for (float t = 0.0f; t < 1.0f; )
{
t +=Time.deltaTime;
transform.rotation = Quaternion.Slerp(orgRot, rotation, t);
yield return null;
}
}
Imagen que muestra diferentes resultados cambiando la posición inicial del cubo, recordar girar la mano de acuerdo a la posición de los ejes, osea apuntar los dedos en sentido a los ejes, que ven en pantalla, o sino se van a confundir:
Bueno expliquemos la imagen, la primera fila podemos ver que tenemos el cubo Rosa volteado hacia abajo, es igual al que explicamos hasta el momento, con una rotacion normal al aplicar LookRotation y Quaternion.Slerp. Nos dio vuelta el cubo violeta, hacia abajo por el producto vectorial es negativo
En la segunda fila podemos ver algo interesante, recordar que si los ángulos entre ellos es de 0 o 180 grados nos dará 0, así que lo único que hará es en transform.rotation = Quaternion.Slerp(orgRot, rotación, t), rotara de su posición original Quaternion orgRot = transform.rotation a 0, ya que el producto vectorial es 0.
En la Tercera fila, vemos que el cubo rotara usando los 3 ejes x, y, z. El resultado del producto vectorial nos dio negativo, al aplicar la regla de la mano derecha el dedo medio apunto hacia abajo, y por lo tanto el eje Z se orientara hacia abajo, y el cubo se dara vuelta apuntando su eje Z, al resultado del producto vectorial negativo. Al ser Quaternion.LookRotation(myForward, target.forward), tratara como decirlo de alguno manera "mirar", hacia la direccion de target.forward, por esa razon el cubo rota "moviendo" los tres ejes, y apuntado mientras termina su recorrido hacia forward osea el eje Z, del target.forward de nuestro cubo Rosa, mientras va finalizando su rotacion, con transform.rotation = Quaternion.Slerp(orgRot, rotation, t);
En la cuarta fila, vamos complicando mas las cosas y trataremos de predicir su rotacion,
Vector3.Cross(transform.up, target.right)
aqui cambiamos el codigo un poco al igual que antes, pero vamos a usar el vector de nuestro "personaje", del eje Y positivo, y el vector de nuestro cubo Rosa, target.right, las imagenes son explicativas, no deberia decir mas, pero el cubo al igual que en la tercera fila, el eje Z tratara orientarse al producto vectorial o producto cruz, en este caso es (0, 0, -1), notar que tambien es interesante que el producto vectorial al darnos negativo, tambien nos dio vuelta nuestro cubo violeta.
Bueno eso es todo le adjuntare el proyecto para que lo descargen y lo estudien si es que quieren ver los resultados, modificando un poco el codigo y viendo como rotara, y lo quieren aplicar en su proyecto, trate de ser bien explicativo, sin envolvernos en palabras complicadas y difiniciones complejas. Que tengan un buen desarrollo, Hasta Pronto!!!
Descargar activos
