Skip to content

Utilidades avanzadas ​

FunciónFirmaDescripción
approxEqual(a: f64, b: f64, tolerance?: f64) => booleanCompara floats dentro de la tolerancia
lerp(start: f64, end: f64, amount: f64) => f64Interpolación lineal
inverseLerp(start: f64, end: f64, value: f64) => f64Interpolación lineal inversa
remap(value: f64, inMin: f64, inMax: f64, outMin: f64, outMax: f64) => f64Remapea valor entre escalas
smoothstep(edge0: f64, edge1: f64, x: f64) => f64Interpolación suave de Hermite
gcd(a: u32, b: u32) => u32Máximo divisor común
lcm(a: u32, b: u32) => u32Mínimo múltiplo común
randomRange(min: f64, max: f64) => f64Float aleatorio en el intervalo semiabierto

approxEqual() ​

Verifica si dos floats son iguales dentro de una tolerancia opcional.

FirmaapproxEqual(a: f64, b: f64, tolerance?: f64): boolean
tyrus
const a: f64 = 1.0;
const b: f64 = 1.0000001;
const result: boolean = approxEqual(a, b);
print(result); // true
tyrus
const a: f64 = 1.0;
const b: f64 = 1.1;
const result: boolean = approxEqual(a, b, 0.05);
print(result); // false

lerp() ​

Interpola linealmente entre dos valores.

Firmalerp(start: f64, end: f64, amount: f64): f64
tyrus
const start: f64 = 0.0;
const end: f64 = 100.0;
const amount: f64 = 0.5;
const result: f64 = lerp(start, end, amount);
print(result); // 50.0

inverseLerp() ​

Devuelve la fracción normalizada de donde un valor está entre dos extremos.

FirmainverseLerp(start: f64, end: f64, value: f64): f64
tyrus
const start: f64 = 0.0;
const end: f64 = 100.0;
const value: f64 = 50.0;
const result: f64 = inverseLerp(start, end, value);
print(result); // 0.5

remap() ​

Remapea un valor de un rango a otro.

Firmaremap(value: f64, inMin: f64, inMax: f64, outMin: f64, outMax: f64): f64
tyrus
const value: f64 = 50.0;
const result: f64 = remap(value, 0.0, 100.0, 0.0, 1.0);
print(result); // 0.5

smoothstep() ​

Devuelve interpolación suave de Hermite entre dos bordes.

Firmasmoothstep(edge0: f64, edge1: f64, x: f64): f64
tyrus
const result: f64 = smoothstep(0.0, 1.0, 0.5);
print(result); // 0.5

gcd() ​

Devuelve el máximo divisor común de dos enteros sin signo.

Firmagcd(a: u32, b: u32): u32
tyrus
const a: u32 = 12;
const b: u32 = 8;
const result: u32 = gcd(a, b);
print(result); // 4

lcm() ​

Devuelve el mínimo múltiplo común de dos enteros sin signo.

Firmalcm(a: u32, b: u32): u32
tyrus
const a: u32 = 4;
const b: u32 = 6;
const result: u32 = lcm(a, b);
print(result); // 12

randomRange() ​

Devuelve un número floating-point aleatorio en el intervalo semiabierto [min, max).

FirmarandomRange(min: f64, max: f64): f64
tyrus
const min: f64 = 1.0;
const max: f64 = 10.0;
const result: f64 = randomRange(min, max);
print(result); // A random float in [1.0, 10.0)