Mathf

Funciones de números para juegos: limitar, interpolar, suavizar, ángulos que dan la vuelta y ruido. Complementa la librería math de Lua, que también está disponible.

local vida = Mathf.clamp(vida - dano, 0, 100)
local t = Mathf.inverseLerp(0, 100, vida)                 -- 0..1
local color = Vec3.lerp(Vec3(1, 0, 0), Vec3(0, 1, 0), t)  -- de rojo a verde
local altura = 2 + Mathf.sin(Time.time * 3) * 0.25        -- flotar arriba y abajo

Constantes

Nombre	Valor
Mathf.pi, Mathf.tau	3.14159... y 2π (una vuelta en radianes).
Mathf.deg2rad, Mathf.rad2deg	Multiplica para pasar de grados a radianes y al revés.
Mathf.infinity, Mathf.negativeInfinity	Infinito (para empezar a buscar un mínimo o un máximo).
Mathf.epsilon	Un número muy pequeño (0.000001).

Básicas

Función	Descripción
Mathf.abs(v), Mathf.sign(v)	Valor absoluto y signo (-1 o 1; el 0 da 1).
Mathf.min(a, b, ...), Mathf.max(a, b, ...)	El menor o el mayor de dos o más números.
Mathf.floor(v), Mathf.ceil(v)	Redondea hacia abajo o hacia arriba.
Mathf.round(v [, decimales])	Redondea al más cercano: Mathf.round(3.14159, 2) = 3.14.
Mathf.sqrt(v), Mathf.pow(a, b), Mathf.exp(v)	Raíz cuadrada, potencia y exponencial.
Mathf.log(v [, base]), Mathf.log10(v)	Logaritmo (natural o en esa base) y en base 10.

Trigonometría

Función	Descripción
Mathf.sin(r), Mathf.cos(r), Mathf.tan(r)	En radianes (usa grados * Mathf.deg2rad).
Mathf.asin(v), Mathf.acos(v), Mathf.atan(v)	Inversas (devuelven radianes; asin y acos no fallan fuera de -1..1).
Mathf.atan2(y, x)	Ángulo de un vector 2D, en radianes (de -π a π).

Rangos e interpolación

Función	Descripción
Mathf.clamp(v, min, max), Mathf.clamp01(v)	Limita un valor a un rango (o a 0..1).
Mathf.lerp(a, b, t)	Valor entre a y b; t se limita a 0..1.
Mathf.lerpUnclamped(a, b, t)	Igual, sin limitar t.
Mathf.inverseLerp(a, b, v)	Lo contrario de lerp: qué t (0..1) le toca a v entre a y b.
Mathf.remap(v, desde1, hasta1, desde2, hasta2)	Pasa un valor de un rango a otro: Mathf.remap(velocidad, 0, 30, 60, 90) para el campo de visión.
Mathf.smoothstep(a, b, v), Mathf.smootherstep(a, b, v)	De 0 a 1 cuando v va de a a b, con arranque y final suaves.
Mathf.approximately(a, b [, margen])	Casi iguales (para comparar decimales: 0.1 + 0.2 ~= 0.3).

Movimiento y suavizado

Función	Descripción
Mathf.moveTowards(actual, objetivo, paso)	Se acerca como mucho paso sin pasarse.
Mathf.smoothDamp(actual, objetivo, vel, tiempo, dt [, maxVel])	Seguimiento suave sin rebote; devuelve el valor y la velocidad (guarda la velocidad para el frame siguiente).
Mathf.wrap(t, largo)	Da la vuelta dentro de 0..largo (el Repeat de Unity). repeat es palabra reservada de Lua; si la necesitas: Mathf["repeat"].
Mathf.pingPong(t, largo)	Va de 0 a largo y vuelve, una y otra vez.

Ángulos (en grados)

Función	Descripción
Mathf.deltaAngle(a, b)	El giro más corto de a a b (-180..180): de 350 a 10 son 20 grados, no -340.
Mathf.lerpAngle(a, b, t)	Interpola ángulos por el camino corto.
Mathf.moveTowardsAngle(a, b, paso)	Gira hacia b como mucho paso grados.

Ruido Perlin

Números "aleatorios" pero continuos: puntos cercanos dan valores parecidos. Sirve para terrenos, nubes, temblores de cámara o movimientos naturales. Siempre dan lo mismo para las mismas coordenadas.

Función	Descripción
Mathf.perlinNoise(x, y)	Ruido 2D de 0 a 1.
Mathf.perlinNoise3(x, y, z)	Ruido 3D de -1 a 1 (usa z = Time.time para que cambie con el tiempo).
Mathf.fractalNoise(x, y [, octavas, persistencia, lacunaridad])	Varias capas de ruido (4 por defecto) para relieve con detalle; de 0 a 1.

-- Temblor de camara natural (no salta como math.random)
local t = Time.time * 12
local temblor = Vec3(Mathf.perlinNoise3(t, 0, 0), Mathf.perlinNoise3(0, t, 0), 0) * 0.15 * fuerza

-- Altura de un terreno
local h = Mathf.fractalNoise(x * 0.02, z * 0.02, 5) * 30

Otras

Función	Descripción
Mathf.isPowerOfTwo(n), Mathf.nextPowerOfTwo(n)	Potencias de dos (tamaños de texturas y rejillas).
Mathf.random(min, max)	Decimal aleatorio (lo mismo que Random.range; ver Random).