109. ESTRUCTURA MATHF (II)

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.