Tutorial de scripts para Unity 3d

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.