Tutorial de scripts para Unity 3d

Examinadas las clases principales de Unity, quisiera ahora realizar una serie de incursiones más o menos extensivas en algunos aspectos del engine que creo que merecen una atención especial, bien por su importancia, bien por la dificultad para entenderlos. Así que, avisando de nuevo en que este que os está escribiendo no es en absoluto un experto en la materia, intentaré ayudar en lo que buenamente pueda.

Quisiera empezar con un acercamiento a todo el componente de físicas del engine, que considero que es el centro neurálgico del noventa y pico por ciento de los videojuegos que se han creado.

Existe entre los recién llegados a Unity bastante confusión entre los términos y conceptos que envuelven su apartado de físicas, y en consecuencia a veces no se aplican correctamente los elementos necesarios para –por ejemplo- detectar adecuadamente una colisión o permitir que un determinado gameobject sea inmune a la gravedad. Para que nuestro juego funcione adecuadamente y no consuma más recursos de los necesarios debemos tener muy claro cuál es la mejor solución para cada necesidad.

Vamos a intentar desgranar para qué sirve cada cosa. Empezaremos por examinar las diferentes posibilidades de detección de colisiones que nos brinda Unity, y para ello necesitaremos introducir el primer concepto:

COLLIDER:

Un collider, en términos muy básicos, es un envoltorio que hace que un determinado objeto se torne sólido y en consecuencia pueda chocar con otros objetos (siempre que a su vez esos otros objetos tengan otro collider). Un collider se compone, por un lado, de una determinada forma (que no tiene por qué coincidir con la forma del objeto, aunque es preferible que “casen” de alguna manera, para originar colisiones creíbles) y, por otro, de un determinado material físico (aquí no estamos hablando de colores o modos de reflejar la luz de una superficie, sino de capacidad de rebote y/o fricción de dicho objeto, así que no confundamos el término “material” que usamos para renderizar un objeto con el material físico).

Atendiendo a su forma, podemos diferenciar los colliders en dos subgrupos: colliders de malla (mesh colliders) y colliders de primitivas (primitive colliders):

El mesh collider lo creamos cuando importamos una malla desde alguna aplicación 3d tipo Blender o 3dMax. Al seleccionar dicha malla desde la vista de Proyecto y previo a importarlo, debemos (caso de querer este tipo de malla) marcar la casilla “generate colliders” (ver captura de pantalla) para que nuestra malla tenga un collider de este tipo.



Cuando marcamos esta casilla e importamos la malla, Unity genera un collider que tendrá la misma forma que dicha malla (de ahí el nombre). Podríamos pensar: “pues ya está, es tan sencillo como pedir a Unity que genere colliders para todas las mallas que vayamos importando y ya tenemos nuestro sistema de detección de colisiones montado, sin necesidad de complicarnos la vida asignando colliders de primitivas que además no cuadran tan perfectamente con nuestras mallas como los colliders de malla”.

Pero no es tan sencillo. Para empezar, dos colliders de malla no colisionarán entre sí si al menos uno de ellos no tiene marcado en el inspector el checkbox “convex”, que hace que el collider envuelva adecuadamente la malla.

“No hay problema” –podemos pensar- “marco la casilla convex y asunto solucionado”.

Sigue sin ser tan sencillo. Si dos colliders de malla colisionan entre sí a una velocidad importante es posible que no se detecte la colisión.

“¿y para el caso de objetos que sé positivamente que no se moverán a mucha velocidad puedo usar mesh colliders?”

La respuesta es: poder, se puede, pero si se puede evitar, mejor. Pensemos que la cantidad de recursos que consume un PC para calcular colisiones derivadas de mallas complejas es muy superior a la precisa para hacer lo propio con primitives colliders.

En resumen, que deberíamos usar los colliders de malla en objetos que sepamos positivamente que en nuestro juego se moverán poco o nada, que no estarán sometidos a colisiones continuas con otros objetos y que tengan una forma difícil de casar con un collider primitivo.


Por su parte, el primitive collider implica asignar a una malla un collider prefabricado por Unity, pudiendo meramente escoger entre las siguientes formas primitivas: esfera, caja, cápsula o rueda. Se trataría meramente de –teniendo nuestra malla seleccionada- irnos al menú Components=>Physics y seleccionar uno de los indicados colliders, para después moverlo de tal forma que encaje lo mejor posible con nuestra malla.

En ocasiones precisaremos usar varios colliders primitivos para cubrir toda la fisonomía de una malla. Esto se puede conseguir creando un gameobject vacío y emparentar dichos colliders como hijos de esta, para crear así una unidad manipulable, por decirlo de alguna forma.

Aunque este segundo sistema –primitive collider- es más trabajoso y antiestético que el anterior- mesh collider- es recomendable que en la medida de lo posible lo usemos para nuestras mallas.

En próximos capítulos ahondaremos en esto. De momento, lo dejamos por hoy.

Es una clase base para otras clases que vamos a introducir dentro de este apartado, para no disgregarlas mucho dado su pequeño tamaño.


CLASE WAITFORSECONDS:

Suspende la ejecución de una corrutina por una cantidad dada de segundos. Sólo puede usarse con una declaración yield en corrutinas. Por ejemplo:

print (Time.time);            //Esto imprimirá 0.

yield WaitForSeconds (5);     //Espera cinco segundos.

print (Time.time);            //Ahora imprime 5.0.

Esta clase sólo la compone su constructor:

static function WaitForSeconds (seconds : float) : WaitForSeconds


CLASE WAITFORFIXEDUPDATE:


Espera hasta la siguiente función de actualización de frames fijados

yield new WaitForFixedUpdate ();

CLASE COROUTINE:


MonoBehaviour.StartCoroutine devuelve una Coroutine. Las instancias de esta clase son usadas sólamente como referencia de esas coroutines y no tienen propiedades ni funciones.

Una coroutine es una function que puede suspender su ejecución (yield) hasta que la instrucción dada YieldInstruction acaba.

Como su nombre indica (y tal como ya hemos visto en algunos ejemplos previamente) esta clase nos permite utilizar características de gran utilidad relacionadas con el tiempo.



VARIABLES DE CLASE:

time:

static var time : float


Es el tiempo en segundos desde el inicio del juego (sólo lectura).

Cuando esta propiedad es llamada desde dentro de la función fixedUpdate devuelve la propiedad fixedTime.

function Update(){
  print(Time.time);
}

No hace falta mucha explicación: nos aparece en pantalla el tiempo transcurrido desde el inicio del juego.


timeSinceLevelLoad:

static var timeSinceLevelLoad : float


Tiempo en segundos desde que el último level ha sido cargado (sólo lectura)


deltaTime:

static var deltaTime : float


El tiempo en segundos que se tardó en completar el último frame (sólo lectura). Debemos usar esta propiedad para hacer que las cosas funcionen de manera independiente a la frecuencia de frames de casa ordenador. Así, cuando multiplicamos dentro de la función Update el movimiento de un objeto con Time.deltaTime estaremos queriendo decir: quiero mover este objeto 10 metros por segundo en lugar de 10 metros por frame.

Recordemos que si llamamos a esta propiedad desde dentro de FixedUpdate, devuelve el delta time de framerate fijo, para adaptarse a éste.

No debemos confiar en Time.deltaTime desde dentro de un onGUI, ya que OnGUI puede ser llamado múltiples veces por frame y delta time debe sostener el mismo valor cada llamada, hasta el siguiente frame en que será actualizado de nuevo.


fixedTime:

static var fixedTime : float


El tiempo desde que el último FixedUpdate comenzó (sólo lectura). Este es el tiempo en segundos desde el inicio del juego. Fixed time es actualizado en intervalos regulares (igual que fixedDeltaTime) hasta que la propiedad time es alcanzada.


maximumDeltaTime:

static var maximumDeltaTime : float


El máximo tiempo que un frame puede tomar. Physics y otras actualizaciones de frecuencia fija de frames (como FixedUpdate) trabajarán solo durante esta duración de tiempo por frame.


smoothDeltaTime:

static var smoothDeltaTime : float


Un Time.deltaTime suavizado.


timeScale:

static var timeScale : float


La escala en la cual el tiempo pasa. Puede ser usada para efectos de cámara lenta. Cuando está establecida en 1.0, el tiempo transcurre igual que en la vida real. Cuando está en 0.5 está el doble de lento que en la vida real. Si lo colocamos en cero el juego se pausa si todas las funciones son independientes del frame rate.

Si bajamos el timeScale es recomendable que también bajemos Time.fixedDeltaTime en la misma cantidad.

Las funcione dentro de FixedUpdate no serán llamadas cuando timeScale esté colocada a cero.


frameCount:

static var frameCount : int


El número total de frames que han pasado (sólo lectura)


realtimeSinceStartup:

static var realtimeSinceStartup : float


El tiempo real en segundos desde que el juego empezó (solo lectura). En casi todos los casos, no obstante, debemos usar Time.time en lugar de esto.


captureFramerate:

static var captureFramerate : int


Si está establecida en un valor superior a 0, el tiempo avanzará en (1.0 / captureFramerate) por frame sin tener en cuenta el tiempo real. Esto es útil si quieres capturar una película donde necesitas una frecuencia de frames constante.

Acceso a la pantalla de información. Esta clase puede ser usada para obtener la lista de las resoluciones soportadas, cambiar la resolución actual, esconder o mostrar el puntero de ratón del sistema, etc.



VARIABLES DE CLASE:

resolutions:

static var resolutions : Resolution[]


Devuelve todas las resoluciones de pantalla completa soportadas por el monitor (read only). Las resoluciones retornadas se ordenan por anchura, empezando por las resoluciones más bajas.

El tipo Resolucion es una estructura con las siguientes variables:

width           Anchura de la resolución en píxeles.
height         Altura de la resolución en píxeles.
refreshRate Tipo de refresco de resolución vertical en Hz. 

currentResolution:

static var currentResolution : Resolution


Variable de sólo lectura que devuelve la resolución de pantalla actual. Si el jugador está corriendo en modo windows, esto devuelve la resolución actual del escritorio.


showCursor:

static var showCursor : boolean


¿Debe el cursor ser visible?

Es enteramente posible implementar un cursor personalizado en lugar del que tiene el sistema. Para hacer esto debemos esconder el del sistema, seguir la posición o movimiento de ratón y mostrar nuestra propia imagen en el lugar preciso.


Vamos a hacer desaparecer nuestro cursor. Para ello previamente eliminamos la luz que creamos en la lección anterior, y luego editamos nuestro Script (que recordaremos que tenemos vinculado a PortaScripts)

Screen.showCursor = false;

Observaremos que cuando pasamos el cursor por encima de la ventana Game, éste se torna invisible.


lockCursor:

static var lockCursor : boolean


¿Debe el cursor ser bloqueado?

El cursor será ocultado automáticamete, centrado en la vista y haciendo que no se pueda abandonar ésta.

Si estamos realizando un juego de navegador web, el cursor podrá sólo ser bloqueado después de que el usuario haya hecho click en el contenido y siempre que éste no abandone la vista presionando escape o cambiando a otra aplicación, ya que en estos casos el cursor será automáticamente desbloqueado. El bloqueo del cursor también se perderá cuando se salga del modo de pantalla completa.

Se puede consultar si el cursor está actualmente bloqueado consultando el estado de lockCursor. Para proveer una buena experiencia de usuario es recomendable sólo bloquear el cursor como resultado de apretar un botón. También debemos consultar si el cursor se desbloquea en orden a pej pausar el juego o hacer surgir un menú del juego. En el Web Player y Editor el cursor automáticamente se desbloqueará cuando aprietes escape. En el Standalone Player tienes control pleno sobre el bloqueo del ratón de manera que no perderás automáticamente el bloqueo del mismo a menos que cambies de aplicación.


width:

static var width : int


La anchura actual de la ventana en la pantalla en píxeles (sólo lectura).

Esta es la actual anchura de la ventana del jugador (en pantalla completa es también la resolución actual)


height:

static var height : int


La altura actual de la ventana en la pantalla en píxeles (sólo lectura)

Esta es la actual altura de la ventana del jugador (en pantalla completa es tambén la resolución corriente)


fullScreen:

static var fullScreen : boolean


¿Está el juego corriendo en pantalla completa?

Es posible intercambiar al modo de pantalla completa cambiando esta propiedad.


sleepTimeout:

static var sleepTimeout : float


Un ajuste de ahorro de energía, permitiendo la atenuación de la pantalla algún tiempo después de la interacción del último usuario activo. Es muy útil para dispositivos táctiles, permitiendo el ahorro de la batería.

SleepTimeout es medido en segundos, donde 0 significa que nunca duerme. El valor por defecto varía de plataforma en plataforma, siendo generalmente distinto a cero el dispositivos móviles.

En dispositivos móviles sería útil colocar esta variable a cero para juegos que usen acelerómetros como principal fuente de entrada. Sin embargo, estos juegos deberían permitir la atenuación de la pantalla mientras están en la pantalla del menú o pausados.


FUNCIONES DE CLASE:

SetResolution:

static function SetResolution (width : int, height : int, fullscreen : boolean, preferredRefreshRate : int = 0) : void


Cambia la resolución de pantalla. Se usará una resolución de anchura por altura dada. Si la resolución indicada no existe o no es soportada por nuestro dispositivo, se usará la mas cercana a la indicada.

Si el parámetro preferredRefreshRate es 0 (default) Unity cambiará a la mayor velocidad de actualización soportada por el monitor.

Si preferredRefreshRate no es cero, Unity la usará si el monitor la soporta, y en otro caso encontrará la más alta soportada.

En la web player sólo podemos cambiar de resolución depués de que el usuario ha hecho click en el contenido. La manera recomendada de hacer esto es cambiar la resolución sólo cuando el usuario haga clic en un botón designado a tal efecto.
El cambio de resolución no sucede inmediatamente, sino cuando el frame actual acaba.

Esta clase se corresponde con las variables que podemos encontrar en el inspector si nos vamos al menú=>edit=>Render Settings.

Contiene valores para un rango de elementos visuales en tu escena, como niebla y luz de ambiente.


VARIABLES DE CLASE:

fog:

static var fog : boolean


¿Está habilitada la niebla?


fogMode:

static var fogMode : FogMode


Modo de niebla a usar. FogMode es una enumeración que admite los siguientes valores:

Linear                Niebla lineal.
Exponential           Niebla exponencial.
ExponentialSquared    Niebla exponencial al cuadrado (por defecto).

fogColor:

static var fogColor : Color


El color de la niebla.


fogDensity:

static var fogDensity : float


La densidad de la niebla exponencial.

Resumamos lo visto con un ejemplo:

RenderSettings.fog = true;
RenderSettings.fogColor = Color.blue;
RenderSettings.fogDensity = 0.1;

Pulsamos play y habremos activado la niebla, que será de color azul y con una densidad de 0.1.


fogStartDistance:

static var fogStartDistance : float


La distancia inicial de la niebla lineal. Las distancias de inicio y final de la niebla son usadas por el modo de niebla Linear.


fogEndDistance:

static var fogEndDistance : float


La distancia final de la niebla lineal (sólo para modo Linear).


ambientLight:

static var ambientLight : Color


Color de la luz de ambiente de la escena.


haloStrength:

static var haloStrength : float


Tamaño del halo de luz. Para cualquier luz, el tamaño del halo es este valr multiplicado por Light.range.


flareStrength:

static var flareStrength : float


La intensidad de las llamas/destellos en la escena.

Vamos a hacer un ejemplo progresivo de la utilidad de estas últimas variables. En primer lugar, eliminamos el script que tenemos vinculado al cubo. Acto seguido editamos MiPrimerScript como sigue:

RenderSettings.ambientLight = Color.green;          

Salvamos y arrastramos a PortaScipts. Al darle al play deberíamos tener una luz de ambiente así:



Démonos cuenta que no ha sido preciso vincularle el script a la luz principal para que tenga efecto.

Ahora nos vamos al menú=>Gameobject=>Create other=>SpotLight. Ubicamos nuestra nueva luz en las coordenadas 0,3,0, con una rotación de 90,0,0, para que se note claramente su efecto y los posteriores cambios. En el inspector, asimismo, marcar la casilla que pone "draw hallo".

Ya que al inicio de este repaso por las clases no cargamos ningún asset, nos faltará uno para completar nuestro ejemplo, así que vamos a menú=>assets=>import Package=>Light Flares. Importamos.

Ahora, de nuevo en el inspector de nuestra spotlight hacemos click en la pequeña fleha que encontramos junto a Flare y seleccionamos Small Flare.

Podemos ya reescribir nuestro script:

RenderSettings.ambientLight = Color.green;
yield WaitForSeconds(5);
RenderSettings.haloStrength = 0.2;
RenderSettings.flareStrength = 0.2;

Dadle al play y observar los cambios transcurridos 5 segundos. HaloStrength afectará al diámetro del haz de luz que pega contra el suelo (la galleta o cookie, que dicen los anglosajones). FlareStrength en cambio se refiere a ese tipo de brillo que emite la fuente de la luz en su origen.


skybox:

static var skybox : Material


El skybox global en uso.

Variables y funciones para la creación y manejo de un rectángulo 2D definido por la posición x,y y anchura, altura. La estructura Rect es principalmente usada para operaciones 2D; el sistema UnityGUI la usa extensamente, además del posicionado de cámaras en la pantalla.


VARIABLES:

x:

var x : float


Coordenada izquierda del rectángulo (a lo largo del eje X).


y:

var y : float


Coordenada superior del rectángulo.



width:

var width : float


Anchura del rectángulo.



height:

var height : float


Altura del rectángulo.


xMin:

var xMin : float


Coordenada izquierda del rectángulo. Cambiando este valor conservamos el lado derecho del rectángulo (así width cambia también)


yMin:

var yMin : float


Coordenada superior del rectángulo. Cambiando este valor conservamos el lado inferior del rectángulo (así height cambiará también)


xMax:

var xMax : float


Coordenada derecha del rectánculo. Cambiando este valor seguimos conservando el lado izquierdo del rectángulo, por lo que la anchura cambiará también.


yMax:

var yMax : float


Coordenada inferior del rectángulo. Cambiando este valor seguimos conservando el lado superior del rectángulo, así que la altura cambiará también.



FUNCIONES:

Rect:

static function Rect (left : float, top : float, width : float, height : float) : Rect


Crea un nuevo rectángulo.


Contains:

function Contains (point : Vector2) : boolean
function Contains (point : Vector3) : boolean


Devuelve true si los componentes x e y del parámetro point conforman un punto dentro del rectángulo

Un breve ejemplo explicativo:

function Update () {
var rect = Rect (0, 0, 150, 150);

if (rect.Contains(Input.mousePosition))
  print("Dentro del rectángulo");

else
  print ("Fuera del rectángulo");
}

Hemos creado primero un plano a partir de las coordenadas 0(izquierda), 0(abajo), con 150 metros/unidades de ancho (a contar desde la izquierda) y otras tantas de alto(contadas desde abajo). Por lo tanto si el ratón lo ubicamos hacia la zona superior derecha se nos mostrará el mensaje de que estamos fuera del rectángulo y si hacemos lo propio hacia la zona inferior izquierda estaremos dentro del rectángulo.


FUNCIONES DE CLASE:

MinMaxRect:

static function MinMaxRect (left : float, top : float, right : float, bottom : float) : Rect


Crea un rectángulo entre min/max valores de coordenadas.

Estructura usada para obtener información de vuelta de un raycast (rayo proyectado).



VARIABLES:

point:

var point : Vector3


El punto de impacto en coordenadas globales donde el rayo golpea el collider


normal:

var normal : Vector3


El normal de la superficie que golpea el rayo.


baryentricCoordinate:

var barycentricCoordinate : Vector3


La coordenada baricéntrica del triángulo que golpeamos (baricentro = es un punto de una figura geométrica la recta que pasa por el cual divide la figura en dos partes iguales. )

Esto nos permite interpolar cualquiera de los datos de los vértices a lo largo de los tres ejes.


distance:

var distance : float


La distancia desde el origen del rayo hasta el punto de impacto.


triangleIndex:

var triangleIndex : int


el índice del triángulo que ha sido golpeado. El índice del triángulo es sólo válido si el colider que lo golpea es un MeshCollider.


textureCoord:

var textureCoord : Vector2


La coordenada de la textura UV en el punto de impacto. Esto puede ser usado para pinturas de textura 3d o impactos de bala dibujados. Si el collider no es una mesh collider, retorna un Vector2 a cero.


textureCoord2:

var textureCoord2 : Vector2


Las coordenadas de la textura uv secundaria.


lightmapCoord:

var lightmapCoord : Vector2


La coordinada del lightmap de uv en el punto de impacto.


colider:

var collider : Collider


El collider que fue golpeado. Esta propiedad es nula si no se golpea nada y no-nula si golpeas algo.


rigidbody:

var rigidbody : Rigidbody


El rigidbody del collider que ha sido golpeado. Si el collider no está vinculado a un rigidbody es null.


transform:

var transform : Transform


El Transform del rigidbody o collider que ha sido golpeado.

Estructura que nos permite representar y modificar rayos. Un rayo es una linea infinita que empieza en un punto dado y va en alguna dirección.


VARIABLES:

origin:

var origin : Vector3


El punto de origen del rayo.


direction:

var direction : Vector3


La dirección del rayo. La dirección es siempre un vector normalizado(1,0,0 o 0,1,0 o 0,0,1. Si asignamos un vector de longitud distinta de la unidad, será normalizado.


FUNCIONES:

Ray:

static function Ray (origin : Vector3, direction : Vector3) : Ray


Crea un rayo que empieza en origin a lo largo de direction.

var ray = new Ray (transform.position, transform.forward);

En este ejemplo crearíamos un rayo que parte de la posición del transform al que está vinculado el script y que parte hasta el infinito a través del eje Z.


GetPoint:

function GetPoint (distance : float) : Vector3

Devuelve un punto tantas unidades como le pasemos en el parámetro a lo largo del rayo.

var r : Ray;
print( r.GetPoint (10) ); 

Este ejemplo imprime un punto situado 10 unidades a lo largo del rayo.


ToString:

function ToString () : String
function ToString (format : String) : String


Devuelve un string formateado para este rayo.

Clase para generar números aleatorios.


VARIABLES DE CLASE:

seed:

static var seed : int


Coloca la semilla para el generador de números aleatorios.


value:

static var value : float


Devuelve un número aleatorio entre 0.0 (inclusive) y 1.0 (inclusive).

for(var x: int =0; x<10; x++){
  print(Random.value);
}

Podréis comprobar que los diez números que nos aparecerán en pantalla están entre ambos valores.


insideUnitSphere:

static var insideUnitSphere : Vector3


Devuelve un punto aleatorio dentro de una esfera con radio 1.

transform.position = Random.insideUnitSphere * 2;

Este ejemplo situaría nuestro cubo en un punto aleatorio dentro de una esfera (3 dimensiones) con un radio de 2 unidades.


insideUnitCircle:

static var insideUnitCircle : Vector2


Devuelve un punto aleatorio dentro de un círculo con radio 1.

var newPosition : Vector2 = Random.insideUnitCircle * 5;

transform.position.x = newPosition.x;
transform.position.y = newPosition.y;

en este caso nuestro cubo se movería dentro de un círculo (2D) con radio de 5 unidades.


onUnitSphere:

static var onUnitSphere : Vector3

Devuelve un punto aleatorio sobre la superficie de una esfera con radio 1.

function FixedUpdate(){
  rigidbody.velocity = Random.onUnitSphere * 10;
}

Esta función mueve al rigidbody de nuestro cubo a una velocidad de 10 en una dirección aleatoria, por lo que no esperéis ver otra cosa al darle al play que un cubo volviéndose loco.


rotation:

static var rotation : Quaternion


Devuelve una rotación aleatoria (read only)

var prefab : GameObject;
Instantiate(prefab, Vector3.zero, Random.rotation);

Este ejemplo instanciaría un nuevo gameobject en el centro de la escena y con una rotación aleatoria.


FUNCIONES DE CLASE:

Range:

static function Range (min : float, max : float) : float


Devuelve un float aleatorio entre un min (inclusive) y max (inclusive).

var prefab : GameObject;

function Start () {
  var position: Vector3 = Vector3(Random.Range(-5.0, 5.0), 0, Random.Range(-5.0, 5.0));
  Instantiate(prefab, position, Quaternion.identity);
}

Si arrastramos la esfera a la variable expuesta prefab, al darle al play observaremos que se clona una instancia de la misma y aparece en un lugar aleatorio en un margen de 5 metros en los ejes X y Z.

static function Range (min : int, max : int) : int

La misma función, pero admite y devuelve integers.

Nuestros amigos los quaterniones son usados para representar rotaciones. Unity internamente usa Quaterniones para representar todas las rotaciones.

Sin embargo, los quaterniones están basados en números complejos y no son fáciles de entender intuitivamente, así que casi nunca accederemos o modificaremos los componentes individuales de un Quaternión (x,y,z,w). Lo que será más habitual es que queramos meramente tomar rotaciones ya existentes (por ej desde un Transform) y usarlas para construir nuevas rotaciones (por ej interpolando suavemente entre dos rotaciones).

Las funciones sobre Quaterniones que usaremos el 99% del tiempo (las otras funciones son para usos exóticos) son Quaternion.LookRotation, Quaternion.Angle, Quaternion.Euler, Quaternion.Slerp, Quaternion.FromToRotation y Quaternion.identity.


VARIABLES:

eulerAngles:

var eulerAngles : Vector3


Devuelve la representacion en ángulos euler de la rotacion.


FUNCIONES:

ToAngleAxis:

function ToAngleAxis (out angle : float, out axis : Vector3): void

Convierte una rotación en una representación de angle-axis (ángulo de eje)


SetFromToRotation:

function SetFromToRotation (fromDirection : Vector3, toDirection : Vector3) : void


Crea una rotación que rota desde fromDirection hasta toDirection.


ToString:

function ToString () : String
function ToString (format : String) : String


Devuelve un string formateado del Quaternion.


VARIABLES DE CLASE:

identity:

static var identity : Quaternion


Sería el equivalente a no rotation. El transform quedará perfectamente alineado con el mundo o con los ejes del padre.


FUNCIONES DE CLASE:

AngleAxis:

static function AngleAxis (angle : float, axis : Vector3) : Quaternion


Crea una rotación que rota los ángulos que le pasemos como primer parámetro con respecto al eje que le pasamos como segundo.

O sea, para girar nuestro cubo (previamente eliminadle el character controller que le añadimos el capítulo anterior), tecleamos:

transform.rotation = Quaternion.AngleAxis(30, Vector3.up);

De esta forma tan simple giramos el cubo 30 grados sobre el eje Y.


FromToRotation:

static function FromToRotation (fromDirection : Vector3, toDirection : Vector3) : Quaternion

Crea una rotación que rota desde el primer parámetro al segundo.

Normalmente usaremos esta función para rotar un transform uno de cuyos ejes sigue un objetivo en una dirección en coordenadas globales.


Slerp:

static function Slerp (from : Quaternion, to : Quaternion, t : float) : Quaternion


Interpola esfériamente del primer al segundo parámetro durante el tercero.


RotateTowards:

static function RotateTowards (from : Quaternion, to : Quaternion, maxDegreesDelta : float) : Quaternion


Efectúa una rotación entre el primer parámetro y el segundo. Esto es esencialmente lo mismo que Quaternion.Slerp, pero aquí la función se aregura de que la velocidad angular nunca exceda de la marcada en maxDegreesDelta. Si maxDegreesDelta tiene un valor negativo la rotación es empujada lejos del segundo parámetro (to).


Angle:

static function Angle (a : Quaternion, b : Quaternion) : float


Devuelve el ángulo en grados entre dos rotaciones dadas.

Veamos eso:

var objetivo : Transform;

function Update () {
   var angulo : float = Quaternion.Angle(transform.rotation, objetivo.rotation);
   Debug.Log(angulo);
}

Arrastramos la esfera a la variable expuesta objetivo. Si pulsamos play, observaremos que nos aparece un cero en pantalla, ya que (si teneis ambas figuras colocadas como yo) ambas tienen sus respectivas rotaciones a 0,0,0. Probad ahora a cambiar la rotación de una -o las dos- figuras.


Euler:

static function Euler (x : float, y : float, z : float) : Quaternion
static function Euler (euler : Vector3) : Quaternion

Devuelve en quaterniones una rotación pasada como parámetro en grados euler.

CapsuleCast:

static function CapsuleCast (point1 : Vector3, point2 : Vector3, radius : float, direction : Vector3, distance : float = Mathf.Infinity, layerMask : int = kDefaultRaycastLayers) : boolean
static function CapsuleCast (point1 : Vector3, point2 : Vector3, radius : float, direction : Vector3, out hitInfo : RaycastHit, distance : float = Mathf.Infinity, layerMask : int = kDefaultRaycastLayers) : boolean

Lanza una cápsula contra todos los colliders de la escena y devuelve información de contra qué ha chocado. Devuelve true cuando el sweep (barrido) de la cápsula choca con algún collider.

Los parámetros de esta función son:

point1      El inicio de la cápsula. 
point2      El fin de la cápsula. 
radius      El radio de la cápsula. 
direction   La dirección en la cual hace el barrido la cápsula. 
hitInfo     Si devuelve true,  hitInfo contendrá más información sobre dónde golpeó 
            el collider. 

distance    La longitud del barrido. 
layerMask   Un Layer mask que se usa para ignorar selectivamente colliders cuando 
            se proyecte la cápsula.  

La cápsula viene conformada por las dos esferas con radios alrededor del point1 y point2, que forman los dos finales de la cápsula. Esto es útil cuando un Raycast no tiene suficiente precisión para lo que queremos hacer, como por ejemplo asegurarnos de que un personaje podrá moverse a cualquier sitio sin colisionar con nada en el camino.


SphereCast:

static function SphereCast (origin : Vector3, radius : float, direction : Vector3, out hitInfo : RaycastHit, distance : float = Mathf.Infinity, layerMask : int = kDefaultRaycastLayers) : boolean


Proyecta una esfera contra todos los colliders de la escena y proporciona información sobre los que colisionan. Devuelve true si topa con alguno en su barrido.

Cuenta con estos parámetros:

origin      El centro de la esfera al principio del barrido. 
radius      El radio de la esfera. 
direction   La dirección en la cual hace el barrido la esfera. 
hitInfo     Si la función devuelve true, esta variable contendrá más información 
            acerca de dónde el collider colisionó (Para más información ver: 
            RaycastHit). 
distance    La longitud del barrido. 
layerMask   Un Layer mask que se usa para ignorar selectivamente colliders cuando 
            se proyecta la cápsula. 

Esta función es útil cuando un Raycast no nos da suficiente precisión, como por ejemplo en el caso en que queramos averiguar si un objeto de un determinado tamaño, como un character, será capaz de de moverse a algún lado sin colisionar con algo por el camino. En casos como estos es preferible usar la función SphereCast.

Hemos de tener presente, eso sí, que la SphereCast no funcionará contra aquellos colliders configurados como triggers.

Probemos un ejemplo. Previamente hay que añadirle un character controller al cubo. Acto seguido tecleamos este script:

function Update () {
  var hit : RaycastHit;
  var charCtrl : CharacterController = GetComponent(CharacterController);
  var p1 : Vector3 = transform.position + charCtrl.center;
 
  if (Physics.SphereCast (p1, charCtrl.height /2, transform.right, hit, 10)) {
     Debug.Log("Hay un obstáculo a " + hit.distance + " metros");
  }
  }

Lo que hemos hecho aquí es, a grandes rasgos, que nuestro cubo efectúe un barrido hacia la derecha en busca de obstáculos para un character con un radio equivalente a la mitad de la altura de nuestro character. Al topar con uno, se muestra un mensaje en pantalla junto con información suplementaria, como en este caso la distancia a que se halla dicho obstáculo. El ejemplo es un poco rupestre, pero nos permite intuir la utilidad de esta función para aplicársela a un personaje.

static function SphereCast (ray : Ray, radius : float, distance : float Mathf.Infinity, layerMask : int = kDefaultRaycastLayers) : boolean
static function SphereCast (ray : Ray, radius : float, out hitInfo : RaycastHit, distance : float = Mathf.Infinity, layerMask : int = kDefaultRaycastLayers) : boolean



CapsuleCastAll:

static function CapsuleCastAll (point1 : Vector3, point2 : Vector3, radius : float, direction : Vector3, distance : float = Mathf.Infinity, layermask : int = kDefaultRaycastLayers) : RaycastHit[]


Es como Physics.CapsuleCast, pero devolviendo todos los colliders que la cápsula intercepta en su barrido e información sobre los mismos. Devuelve un array con todos esos colliders.

Parámetros:

point1       El principio de la cápsula. 
point2       El final de la cápsula. 
radius       El radio de la cápsula. 
direction     La dirección en la cual efectúa el barrido la cápsula. 
distance      La longitud del barrido. 
layerMask     Un Layer mask que se usa para ignorar selectivamente algunos 
              colliders cuando se proyecta la cápsula 

La cápsula es definida por las dos esferas con su radio alrededor de point1 y point2, que forman los dos extremos de la cápsula. Son devueltos datos de todos los colliders contra los que nuestra cápsula proyectada choque en esa dirección.

Recordemos que esta función no funciona contra colliders configurados como triggers.


SphereCastAll:

static function SphereCastAll (origin : Vector3, radius : float, direction : Vector3, distance : float = Mathf.Infinity, layerMask : int = kDefaultRaycastLayers) : RaycastHit[]

static function SphereCastAll (ray : Ray, radius : float, distance : float = Mathf.Infinity, layerMask : int = kDefaultRaycastLayers) : RaycastHit[]

Como physics.SphereCast, pero devolviendo todos los colliders que colisionen.


CheckSphere:

static function CheckSphere (position : Vector3, radius : float, layerMask : int = kDefaultRaycastLayers) : boolean


Devuelve true si hay algún collider tocando la esfera definida por position y radius en coordenadas globales.


CheckCapsule:

static function CheckCapsule (start : Vector3, end : Vector3, radius : float, layermask : int = kDefaultRaycastLayers) : boolean


Devuelve true si hay algún collider tocando la cápsula definida por el eje que va de start a end y que tiene el radio radius, en coordenadas globales.


IgnoreCollision:

static function IgnoreCollision (collider1 : Collider, collider2 : Collider, ignore : boolean = true) : void


Hace que el sistema de detección de colisiones ignore todas las colisiones entre collider1 y collider2. Esto es muy útil por ejemplo para que los proyectiles no colisionen con el objeto que los dispara.


Esta función tiene algunas limitaciones:

1.- No es persistente. Esto significa que el estado de ignorar colisión no será almacenado en el editor cuando se salve la escena.
2.- Sólo puedes aplicar esta función a colliders en gameobjects activos. Cuando se desactiva el collider o el rigidbody vinculado se pierde el estado de IgnoreCollision y tendrás que llamar a esta función otra vez.


IgnoreLayerCollision:

static function IgnoreLayerCollision (layer1 : int, layer2 : int, ignore : boolean = true) : void


Hace que el sistema de detección de colisiones ignore todas las colisiones entre cualquier collider en layer1 y otros en layer2.


GetIgnoreLayerCollision:

static function GetIgnoreLayerCollision (layer1 : int, layer2 : int) : boolean


Booleano que indica si las colisiones entre layer1 y layer2 están siendo ignoradas.

Componen esta clase, al igual que la estructura Mathf anterior, propiedades globales y métodos de ayuda relacionados con las físicas.



VARIABLES DE CLASE:

gravity:

static var gravity : Vector3


La gravedad aplicada a todos los rigidbodies en la escena. Puede ser desconectada para un rigidbody individual usando su propiedad useGravity.


FUNCIONES DE CLASE:

Raycast:

static function Raycast (origin : Vector3, direction : Vector3, distance : float = Mathf.Infinity, layerMask : int = kDefaultRaycastLayers) : boolean

Lanza un rayo contra todos los colliders en la escena. Devuelve true cuando el rayo intersecta algún collider.

Tiene los siguientes parámetros:

origin             El punto inicial del rayo en coordenadas globales. 
direction     La dirección del rayo. 
distance     La longitud o fuerza del rayo. 
layerMask     Una máscara de distribución (Layer mask) que se usa para ignorar
                    selectivamente colliders cuando se proyecta un rayo. 

Por ejemplo:

function Update () {
  var derecha : Vector3 = transform.TransformDirection (Vector3.right);
  if (Physics.Raycast (transform.position, derecha, 10)) {
  print ("Hay algo a mi derecha");
}
}

Lo que hacemos aquí es primero tomar la dirección local de nuestro cubo y convertirla en dirección global, a través de la función TransformDirection. Dicha dirección global la almacenamos en la variable "derecha". Acto seguido, imprimimos un mensaje si desde la posición de nuestro cubo en una distancia no superior a diez metros hay a la derecha global del mismo otro objeto.

static function Raycast (origin : Vector3, direction : Vector3, out hitInfo : RaycastHit, distance : float = Mathf.Infinity, layerMask : int = kDefaultRaycastLayers) : boolean

Proyecta un rayo contra todos los colliders en la escena y devuelve información detallada sobre qué golpeó.

Los parámetros de este segundo prototipo de función son:

origin        El punto de inicio del rayo en coordenadas globales. 
direction      La dirección del rayo. 
distance       La fuerza o longitud del rayo. 
hitInfo        Si se devuelve true, esta variable contendrá más información sobre 
               donde colisionó el collider. 
layerMask      Un layer mask usado para ignorar colliders selectivamente cuando se 
               proyecte un rayo.  

static function Raycast (ray : Ray, distance : float = Mathf.Infinity, layerMask : int = kDefaultRaycastLayers) : boolean
static function Raycast (ray : Ray, out hitInfo : RaycastHit, distance : float = Mathf.Infinity, layerMask : int = kDefaultRaycastLayers) : boolean

Son similares a las funciones anteriores, sólo que usando ray.origin y ray.direction en vez de origen y dirección como sendos Vector3.


RaycastAll:

static function RaycastAll (ray : Ray, distance : float = Mathf.Infinity, layerMask : int = kDefaultRaycastLayers) : RaycastHit[]
static function RaycastAll (origin : Vector3, direction : Vector3, distance : float = Mathf.Infinity, layermask : int = kDefaultRaycastLayers) : RaycastHit[]

Lanza un rayo a través de la escena y devuelve todos los choques.

Vamos a adaptar un ejemplo del manual de referencia:

function Update () {

var choques : RaycastHit[];
choques = Physics.RaycastAll (transform.position, transform.right, 100.0);

for (var i = 0;i < choques.Length; i++) {
  var miChoque : RaycastHit = choques[i];
  var renderer = miChoque.collider.renderer;

  if (renderer) {
      renderer.material.shader = Shader.Find("Transparent/Diffuse");
      renderer.material.color.a = 0.3;
}
}
}

Vamos paso a paso en la explicación. Primero declaramos una variable que contendrá un array de tipo RaycastHit, que es precisamente lo que hemos visto que devuelve la función RaycastAll. La inicializamos con todas aquellas colisiones que sufra nuestro rayo, el cual proyectamos desde el cubo 100 metros a la derecha.

Dado que puede haber más de una colisión, iteramos a través del array y el collider con el que se ha producido cada colisión le es asignado temporalmente a la variable miChoque, a través de la cual lo volvemos semitransparente.

Si pulsamos play vemos que nuestra esfera se torna semiinvisible.


LineCast:

static function Linecast (start : Vector3, end : Vector3, layerMask : int = kDefaultRaycastLayers) : boolean


Devuelve true si hay algún collider intersectando la línea entre start y end.


static function Linecast (start : Vector3, end : Vector3, out hitInfo : RaycastHit, layerMask : int = kDefaultRaycastLayers) : boolean


En este segundo prototipo, si se devuelve true, hitinfo contendrá más información sobre dónde colisionó el collider.


OverlapSphere:

static function OverlapSphere (position : Vector3, radius : float, layerMask : int = kAllLayers) : Collider[]


Devuelve un array con todos los colliders que toquen o estén dentro de la esfera cuya posición y radio pasamos como parámetros.

SmoothDamp:

static function SmoothDamp (current : float, target : float, ref currentVelocity : float, smoothTime : float, maxSpeed : float = Mathf.Infinity, deltaTime : float = Time.deltaTime) : float


Gradualmente cambia un valor hacia un objetivo en un determinado tiempo. La función se puede usar para suavizar la transición de valores, colores, posiciones, escalares….

Cuenta con los siguientes parámetros:

current          La posición actual. 
target           La posición que estamos tratando de alcanzar. 
currentVelocity  La velocidad actual. Este valor es modificado por la función cada 
                 vez que la llamamos. 
smoothTime       Aproximadamente el tiempo que tardaremos en alcanzar el objetivo. 
                 Un valor pequeño hará que allcancemos el objetivo más rápido.
maxSpeed         Opcionalmente nos permite fijar la velocidad máxima. 
deltaTime        El tiempo desde la última llamada a esta función. Por defecto
                 Time.deltaTime. 

Un ejemplo:

var objetivo : Transform;
var tiempoEmpleado = 3;
private var yVelocity =4.0;

function Update () {
  var newPosition : float = Mathf.SmoothDamp(transform.position.x, 
  objetivo.position.x, yVelocity, tiempoEmpleado);
  transform.position = Vector3(newPosition, transform.position.y, 
  transform.position.z);
}

Salvamos y arrastramos el cubo a la variable expuesta "objetivo". Lo que aquí estamos haciendo es usar la función SmoothDamp para ir marcando la nueva posición de nuestro cubo. El punto de origen será la posición actual del cubo (en el eje x), el destino la posición actual en dicho eje del transform que marcamos como objetivo, le establecemos un tiempo para que el origen alcance al objetivo de 3 segundos y le limitamos la velocidad máxima que pueda alcanzar nuestro cubo a cuatro metros por segundo.


SmoothDampAngle:

static function SmoothDampAngle (current : float, target : float, ref currentVelocity : float, smoothTime : float, maxSpeed : float = Mathf.Infinity, deltaTime : float = Time.deltaTime) : float


Cambia gradualmente un ángulo dado en grados hacia el ángulo que constituye el objetivo en un tiempo determinado. El uso más común de esta función es para suavizar una cámara que esté siguiendo algún personaje o escena.


Repeat:

static function Repeat (t : float, length : float) : float


Introduce en un bucle el valor t, de tal manera que nunca sea más grande que length y nunca más pequeño que 0.


PingPong:

static function PingPong (t : float, length : float) : float


Hace rebotar el valor t, de tal manera que nunca sea mayor que length y nunca mayor que 0. El valor retornado se moverá atrás y adelante entre 0 y length.


InverseLerp:

static function InverseLerp (from : float, to : float, value : float) : float


Calcula el parámetro Lerp entre dos valores.


ClosestPowerOfTwo:

static function ClosestPowerOfTwo (value : int) : int


Retorna la potencia de dos más cercana.


IsPowerOfTwo:

static function IsPowerOfTwo (value : int) : boolean


Devuelve true si el valor es potencia de dos


NextPowerOfTwo:

static function NextPowerOfTwo (value : int) : int

Devuelve el valor de la siguiente potencia de dos.


DeltaAngle:

static function DeltaAngle (current : float, target : float) : float


Calcula la diferencia más corta entre dos ángulos dados.

Ceil:

static function Ceil (f : float) : float


Devuelve el integer más pequeño igual o mayor que f.


Floor:

static function Floor (f : float) : float


Devuelve el mayor integer igual o más pequeño que f.


Round:

static function Round (f : float) : float


Devuelve f redondeado al integer más cercano. Si el número acaba en .5 y queda entre dos integers, uno de los cuales es par y el otro impar, se devolverá el numero par.


CeilToInt:

static function CeilToInt (f : float) : int


Devuelve el integer más pequeño igual o mayor que f.


FloorToInt:

static function FloorToInt (f : float) : int


Devuelve el mayor integer menor o igual que f.


RoundToInt:

static function RoundToInt (f : float) : int


Devuelve f rendondeada al integer más cercano. Si e número acaba en .5 y por lo tanto está a medio camino entre dos integers, uno impar y el otro par, se devuelve el número par.


Sign:

static function Sign (f : float) : float


Devuelve el signo de f. Devuelve 1 si es positivo o cero, y -1 si f es negativo.


Clamp:

static function Clamp (value : float, min : float, max : float) : float
static function Clamp (value : int, min : int, max : int) : int

Restringe un valor entre un mínimo y un máximo, sean floats o ints.

Vamos a verlo con un ejemplo:

for(var x : int = 0; x <= 10; x++) {
  var numeroFijado : int = Mathf.Clamp(x, 1, 5); 
  Debug.Log(numeroFijado);
}

Mediante un bucle for le pasamos como primer parámetro a la función Clamp números del 10 al diez. Si desplegamos la consola tras probar este ejemplo veremos que cuando x vale 0, clamp devuelve el valor mínimo fijado (en este caso 1). Lo mismo pasa cuando x vale más de 5.


Clamp01:

static function Clamp01 (value : float) : float

Fija un valor entre 0 y 1 y lo devuelve.


Lerp:

static function Lerp (from : float, to : float, t : float) : float


Interpola a hacia b pasando por t. t queda fijada entre 0 y 1. Cuando t = 0 devuelve from. Cuando t = 1 devuelve to. Cuando t = 0.5 devuelve la media de a y b.


LerpAngle:

static function LerpAngle (a : float, b : float, t : float) : float


Lo mismo que lerp, pero asegurándonos de interpolar valores correctamente cuando dé un giro de 360 grados. Las variables a y b representan grados.

Para ilustrar esta función y la anterior vamos a apañar un pequeño ejemplo. Sería interesante que eliminárais el script vinculado a la esfera. Editamos:

var origen = -2.0;
var destino = 1.0;
var anguloInicial= 0.0;
var anguloFinal= 90.0;

function Update () {
  transform.position = Vector3(Mathf.Lerp(origen, destino, Time.time * 0.1), 0, 0);

  var angle : float = Mathf.LerpAngle(anguloInicial, anguloFinal, Time.time * 0.1);
  transform.eulerAngles = Vector3(0, angle, 0);
}

Salvamos y vinculamos el script al cubo. A la función Lerp le pasamos el parámetro de situación inicial -2, que coincide con su posición actual en el eje x, y le indicamos un destino en 1. Tradicionalmente como tercer parámetro se coloca Time.time, que pasa de 0 a 1 en un segundo, pero como queremos que el trayecto sea más lento, multiplicamos Time.time por 0.1, de tal manera que el trayecto total dure 10 segundos.

Otro tanto hacemos con el angulo inicial y final. Como resultado, el cubo se moverá tres metros en el eje X y girará 90 grados sobre el eje Y en diez segundos.


MoveTowards:

static function MoveTowards (current : float, target : float, maxDelta : float) : float


Mueve el valor que indicamos en el parámetro current hacia el que indicamos en target. Hasta aquí la función sería parecida a Mathf.Lerp, pero aquí nos aseguramos de la que velocidad no exceda de maxDelta. Valores negativos para maxDelta empuja el valor lejos del objetivo.


MoveTowardsAngle:

static function MoveTowardsAngle (current : float, target : float, maxDelta : float) : float


Lo mismo que MoveTowards pero estando seguros de que los valores se interpolarán correctamente cuando gire 360 grados.

La diferencia de MoveTowards y MoveTowardsAngle con respecto de Lerp y LerpAngle la veremos más fácilmente rehaciendo el script anterior:

var origen = -2.0;
var destino = 1.0;
var minAngle = 0.0;
var maxAngle = 90.0;

function Update () {
  transform.position = Vector3(Mathf.MoveTowards(origen, destino, Time.time * 1),  
  0,0);

  var angle : float = Mathf.MoveTowardsAngle(minAngle, maxAngle, Time.time * 30);
  transform.eulerAngles = Vector3(0, angle, 0);
}

La diferencia la tenemos que hallar en el tercer parámetro. En el caso de MoveTowards lo que le estamos pidiendo aquí al cubo es que se mueva en el eje x de la posición -2 a la 1 (3 metros, o sea) a razón de un metro por segundo. Y Para MoveTowardsAngle estamos indicándole al cubo que gire 90 grados a razón de 30 grados por segundo. De esta manera, en 3 segundos el cubo debería haber completado ambos movimientos. Probadlo.


SmoothStep:

static function SmoothStep (from : float, to : float, t : float) : float

Interpola entre mínimo y máximo y facilita entrada y salida de los límites. Sería como Lerp, pero con un impulso inicial. Si meramente sustituís em el último script MoveTowards por SmoothStep veréis a qué me refiero.


Approximately:

static function Approximately (a : float, b : float) : boolean

Compara si dos valores en punto flotante son similares. Debido a que los numeros en punto flotante son imprecisos no es recomendable compararlos usando el operador == (podría no devolver true), y es mejor utilizar esta función.

Estructura que contiene una colección de funciones matemáticas que podemos usar para nuestros scripts.


VARIABLES DE CLASE:

PI:

static var PI : float

El famoso 3.141592. (sólo lectura)

Como pequeña anotación, observad que las variables de clase de Mathf comienzan por mayúscula, al contrario de las variables de clase del resto de clases y funciones en Unity. Tenedlo presente, ya que es una fuente importante de errores.


Infinity:

static var Infinity : float

Representación del infinito positivo (sólo lectura)


NegativeInfinity:

static var NegativeInfinity : float


Una representación del infinito negativo (sólo lectura)


Deg2Rad:

static var Deg2Rad : float


Conversión constante de grados a radianes (sólo lectura)


Rad2Deg:

static var Rad2Deg : float


Conversión constante de radianes a grados (sólo lectura)


Epsilon:

static var Epsilon : float


El valor más pequeño que un float puede tener diferente de cero (sólo lectura)


FUNCIONES DE CLASE:

Sin:

static function Sin (f : float) : float


Devuelve el seno del ángulo f en radianes.


Cos:

static function Cos (f : float) : float

Devuelve el coseno del ángulo f en radianes.


Tan:

static function Tan(f : float) : float


Devuelve la tangente del ángulo f en radianes.


Asin:

static function Asin (f : float) : float


Devuelve el arco seno de f menos el ángulo en radianes cuyo seno es f.


Acos:

static function Acos (f : float) : float


Devuelve el arco coseno de f menos el ángulo en radianes cuyo coseno es f.


Atan:

static function Atan (f : float) : float


Devuelve el arco tangente de f menos el ángulo en radianes cuya tangente es f.


Atan2:

static function Atan2 (y : float, x : float) : float


Devuelve el ángulo en radianes cuya tangente es y/x.

El valor retornado es el ángulo entre el eje X y un vector 2D que empieza en cero y acaba en (x,y)


Sqrt:

static function Sqrt (f : float) : float


Devuelve la raíz cuadrada de f.


Abs:

static function Abs (value : float) : float
static function Abs (value : int) : int

Devuelve el valor absoluto de value.


Min:

static function Min (a : float, b : float) : float
static function Min (params values : float[]) : float
static function Min (a : int, b : int) : int
static function Min (params values : int[]) : int

Devuelve el valor mínimo de dos o más valores dados.


Max:



static function Max (a : float, b : float) : float
static function Max (params values : float[]) : float
static function Max (a : int, b : int) : int
static function Max (params values : int[]) : int

Devuelve el valor máximo de dos o más valores.


Pow:

static function Pow (f : float, p : float) : float

Devuelve f elevado a la potencia p.


Exp:

static function Exp (power : float) : float


Devuelve la potencia natural de un determinado número.


Log:

static function Log (f : float, p : float) : float
static function Log (f : float) : float


Devuelve el logaritmo de un determinado número en una base especificada.


Log10:

static function Log10 (f : float) : float


Devuelve el logaritmo en base diez de un determinado número.

Almacena los mapas de luces (lightmaps) de la escena.

Una escena puede tener varios lightmaps almacenados en ella, y suss componentes Renderer pueden usar esos lightmaps. Esto hace posible usar el mismo material en múltiples objetos, mientras cada objeto puede referirse a diferentes lightmaps o diferentes porciones del mismo lightmap.


VARIABLES DE CLASE:

lightmaps:

static var lightmaps : LightmapData[]


Es un array de tipo LightmapData que puede almacenar diferentes lightmaps. LightmapData es una clase con dos variables:

lightmapFar:          Lightmap que almacena la totalidad de la luz entrante.
lightmapNear:         Lightmap que almacena sólo la luz indirecta entrante.

lightsmapMode:

static var lightmapsMode : LightmapsMode


Modo de renderizado de lightmaps. LightmapsMode es una enumeración con los siguientes dos valores:

Single:       Modo de renderizado de lightmap tradicional.
Dual:         Modo de renderizado de lightmap dual.

Los Gizmos son usados para permitir un debug visual o bien para colocar ayudas en la vista de escena.

Todos los gizmos deben ser dibujados o con la función OnDrawGizmos o con la función. OnDrawGizmosSelected. La diferencia de ambas es que:

OnDrawGizmos es llamada cada frame.
OnDrawGizmosSelected es llamada sólo si el objeto al cual está vinculado el script es seleccionado.


VARIABLES DE CLASE:

color:

static var color : Color


Establece el color para los gizmos que serán dibujados a continuación.

Vamos a hacer un pequeño ejemplo. Aseguráos de que MiPrimerScript sigue estando vinculado a la esfera, y acto seguido deseleccionar cualquier gameobject haciendo click en un espacio vacío de la Jerarquía. Comprobamos que en la vista game tengamos marcada la pestaña Gizmos. Escribimos:

function OnDrawGizmosSelected () {
  Gizmos.color = Color.blue;
  var direction : Vector3 = transform.TransformDirection (Vector3.forward) * 5;
  Gizmos.DrawRay (transform.position, direction);
}

Le damos al play y no parece ocurrir nada. Esto es porque estamos llamando a la función OnDrawGizmosSelected, que sólo muestra el dibujo cuando seleccionamos el objeto al cual va vinculado el script, así que en la jerarquía seleccionamos la esfera y automáticamente nos debería aparecer una línea de color azul que va desde la posición del transform de la esfera cinco metros en adelante.


FUNCIONES DE CLASE:

DrawRay:

static function DrawRay (r : Ray) : void
static function DrawRay (from : Vector3, direction : Vector3) : void

Dibuja un rayo que empieza desde from hasta from + direction. Lo hemos visto en funcionamiento en el ejemplo anterior.


DrawWireSphere:

static function DrawWireSphere (center : Vector3, radius : float) : void


Dibuja una esfera de alambre con centro y radio.

var radio = 2.0;

function OnDrawGizmos() {
  Gizmos.color = Color.cyan;
  Gizmos.DrawWireSphere (transform.position, radio);
}

Meramente como apunte, aquí la esfera de alambre se ve tengamos o no seleccionado el game object esfera, porque la hemos dibujado con la función OnDrawGizmos.


DrawSphere:

static function DrawSphere (center : Vector3, radius : float) : void


Dibuja una esfera sólida con centro y radio.


DrawWireCube:

static function DrawWireCube (center : Vector3, size : Vector3) : void


Dibuja una caja de alambre con centro y tamaño.


DrawCube:

static function DrawCube (center : Vector3, size : Vector3) : void


Dibuja una caja sólida con centro y tamaño.


DrawIcon:

static function DrawIcon (center : Vector3, name : String) : void

Dibuja un icono en posición global en la vista de escena. El icono deberá tener el mismo nombre que le asignamos al parámetro name y estará ubicado en las coordenadas que le pasemos al parámetro center. El path del icono puede encontrarse en la carpeta Assets/Gizmos.

Vamos por partes: Antes que nada necesitamos una imagen tipo icono. Yo para el ejemplo he usado ésta.

Renombramos a la imagen como "nave". Por otro lado, en el archivo donde estamos guardando estos ejemplos, dentro de la carpeta assets, hemos de crear una carpeta llamada Gizmos, que es el path que Unity buscará para dar con los iconos de este tipo. Luego arrastramos nuestra nave a la recién creada carpeta.

Y ahora editamos el script:

function OnDrawGizmos () {
   Gizmos.DrawIcon (transform.position + Vector3(0,2,0), "nave.png");
}

Pulsamos el play, y dos metros por encima de nuestra esfera debería aparecernos la nave, tal que así:




DrawGUITexture:

static function DrawGUITexture (screenRect : Rect, texture : Texture, mat : Material = null) : void
static function DrawGUITexture (screenRect : Rect, texture : Texture, leftBorder : int, rightBorder : int, topBorder : int, bottomBorder : int, mat : Material = null) : void


Dibuja una textura en coordenadas de pantalla. Es útil para backgrounds de GUI.

FUNCIONES:

GetTypeFromControl:

function GetTypeForControl (controlID : int) : EventType


Esta función devuelve un tipo de evento que es filtrado para un determinado control cuya id pasamos como parámetro. Esta función es usada para implementar bloqueos de ratón y de focos de teclado.

El id del control para el que requerimos el tipo de evento se obtiene de GUIUtilty.GetControlID (), y en EventType podemos ver una lista de sus posibles valores.


Use:

function Use () : void


Evento ya utilizado. deberíamos llamar a este método cuando ya hemos usado un evento. El tipo de evento será colocado en EventType.Used, causando que otros elementos GUI lo ignoren.


VARIABLES DE CLASE:

current:

static var current : Event


El evento actual/corriente que está siendo procesado en este mismo momento.

Un ejemplo:

function OnGUI() {
   var miEvento : Event = Event.current;
   if(miEvento.type != EventType.repaint && miEvento.type != EventType.layout){
 Debug.Log("Current detected event: " + Event.current);
}
}

Salvamos y tras pulsar al play disparamos los eventos que deseemos. Detenemos el reproductor y accedemos a la consola donde se muestran los mensajes haciendo click sobre el último y ahí tendremos toda la información sobre teclas pulsadas, movimientos y clics del ratón, etc. Observaréis que descarté la impresión de eventos de tipo repaint y layout, que son los que se producen de manera automática y en un número mayor.

clickCount:

var clickCount : int


Cuántos clicks de ratón consecutivos hemos recibido.

Es usado en el evento EventType.MouseDown. Usadlo para diferenciar entre un click único y un doble click.

Un ejemplo:

private var numeroClicks : int = 0;

function OnGUI() {
  var miEvento : Event = Event.current;
  if (miEvento.isMouse) {
     numeroClicks +=miEvento.clickCount;
     Debug.Log("Mouse clicks: " + numeroClicks);
}
}

Si lo probamos, vemos que tenemos un contador de clicks que contabiliza cada actividad (down y up) del botón del ratón desde el inicio del juego. Es una adaptación del script que está en el manual de referencia. Si os fijáis, declaramos la variable numeroClicks fuera de la función onGUI, para que no nos contabilice (como hace en el manual de referencia) los clicks de cada frame, sino los totales. Por lo demás, el script no tiene mucho misterio: inicializamos una variable de tipo Event con el evento actual, nos aseguramos de que el evento tenga que ver con el ratón y pasamos a contar clicks.


character:

var character : char


El tipo de caracter.

function OnGUI() {
   var miEvento : Event = Event.current;
   if (miEvento.isKey) {
       Debug.Log("Pulsado caracter: " + miEvento.character);
}
}

commandName

var commandName : String


El nombre de un evento de tipo ExecuteCommand o Validate Command ("Copy", "Cut", "Paste", "Delete", "FrameSelected", "Duplicate", "SelectAll", etc)


keyCode:

var keyCode : KeyCode


El key code para eventos de teclado. Usado en los eventos EventType.KeyDown y EventType.KeyUp; devuelve el valor del KeyCode, por lo que se usa para manejar, por ejemplo, teclas de cursor, de funciones, etc.

Teclead este código y tras salvar y darle al play pulsad por ejemplo una de las flechas de desplazamiento del teclado:

function OnGUI() {
  var miEvento : Event = Event.current;
  if (miEvento.isKey) {
     Debug.Log("El key code es: " + miEvento.keyCode);
}
}

shift:

var shift : boolean


¿Está shift pulsado? (sólo lectura)


control:

var control : boolean


¿Está control pulsado? (sólo lectura)


alt:

var alt : boolean


¿Está alt pulsado? (Sólo lectura)


capsLock:

var capsLock : boolean


¿Está el bloqueo de mayúsculas pulsado? (sólo lectura)


numeric:

var numeric : boolean


¿Se está presionando alguna tecla del teclado numérico) (sólo lectura)


functionKey:

var functionKey : boolean


¿Es la tecla presionada una tecla de función (alt, ctrl, shift, etc)? (Sólo lectura)


isKey:

var isKey : boolean


¿Es este evento un evento de teclado? (sólo lectura)


isMouse:

var isMouse : boolean


¿Es este evento un evento de ratón? (sólo lectura)