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.
