Mathf

Скалярная математика — функции «только с числами», к которым тянешься внутри покадрового цикла. Mathf — это обычный объект с функциями и константами, ничего создавать не нужно. Векторы, кватернионы и матрицы живут на Vec2 / Vec3, Quat и Mat4, а не здесь.

Обзор

TypeScript
class Chase extends Aspect<'chase'> {
  target?: Node
  follow = Mathf.smoothDamp([0, 0, 0], 0.15)          // сглаживатель с состоянием: один на аспект, никогда не на кадр
  onAttach() { this.follow.setValue([...this.node.position]) }   // стартуем с того места, где стоит узел
  update(dt: number) {
    if (this.target) this.node.position = this.follow([...this.target.position], dt)
  }
}

const scene = new Scene()
const hero = Mesh.sphere({ material: Material.lit({ color: '#4f7cff' }), position: [3, 0, -5] })
const buddy = Mesh.sphere({ material: Material.lit({ color: '#e33' }) }).aspect(Chase, { target: hero })
scene.add(hero, buddy)
scene.open()

const hp = Mathf.clamp(120, 0, 100)                            // 100
const fill = Mathf.lerp(0, 200, Mathf.inverseLerp(0, 50, 20))  // 80: 20 из 50 → 40 % от 200
const angle = Mathf.repeat(370, 360)                           // 10
const zoom = Mathf.damp(1, 2, 10, 1 / 60)                      // один кадр (60 Гц) сглаживания, не зависящего от FPS

Константы и перевод углов

TypeScript
Mathf.PI            // Math.PI
Mathf.TAU           // 2π — полный оборот в радианах
Mathf.EPSILON       // 1e-6
Mathf.DEG2RAD       // π / 180
Mathf.RAD2DEG       // 180 / π
Mathf.deg2rad(deg): number
Mathf.rad2deg(rad): number
Note

DEG2RAD / RAD2DEG есть и как «голые» глобалы времени компиляции (без префикса Mathf.) — какие API принимают градусы, а какие радианы, смотри в соглашениях.

Диапазоны и интерполяция

TypeScript
Mathf.clamp(v, min, max): number
Mathf.clamp01(v): number                              // зажать в [0, 1]
Mathf.lerp(a, b, t): number                           // a + (b − a)·t
Mathf.inverseLerp(a, b, v): number                    // где v лежит в [a, b] как 0..1 (0, если a === b)
Mathf.remap(v, inMin, inMax, outMin, outMax): number  // перенести v из одного диапазона в другой
Mathf.sign(x): number                                 // -1, 0 или 1 (Math.sign)
Mathf.repeat(t, length): number                       // зациклить t в [0, length)
Mathf.pingPong(t, length): number                     // t «отскакивает» туда-обратно в [0, length]

Сглаживание к значению

TypeScript
Mathf.moveTowards(a, b, maxDelta): number         // линейный шаг, никогда не перелетает цель
Mathf.damp(a, b, lambda, dt): number              // экспоненциальное приближение, не зависит от FPS

damp — безопасная по частоте кадров замена a = lerp(a, b, 0.1) на каждом кадре: lambda — скорость (больше = резче; хорошие значения 5..15), dt — длительность кадра в секундах (dt из update(dt)). Функция без состояния — передавай ей обратно значение с прошлого кадра.

smoothDamp — критически задемпфированное слежение (как SmoothDamp в Unity)

TypeScript
Mathf.smoothDamp(initial: number,   smoothTime, maxSpeed?): Damper<number>
Mathf.smoothDamp(initial: number[], smoothTime, maxSpeed?): Damper<number[]>  // массивы vec2/vec3

const damper = Mathf.smoothDamp([0, 0], 0.15)
damper(target, dt)          // вызывай каждый кадр → новое сглаженное значение
damper.setValue(v)          // задать внутреннее состояние (телепорт) — убирает «резинку»

Возвращает сглаживатель с состоянием, который сам отслеживает свою скорость, поэтому движение плавно разгоняется и тормозит без перелёта. smoothTime — примерно время выхода на цель в секундах; maxSpeed (по умолчанию Infinity) ограничивает скорость — для массивов ограничение применяется к длине вектора, а не покомпонентно. Форма с массивом на каждый вызов возвращает новый массив. Chase из обзора — обычная схема: сглаживатель — поле аспекта, вызываемое из update(dt).

Note

создавай сглаживатель один раз — полем, а не локальной переменной в update. Новый сглаживатель каждый кадр сбрасывает скорость и сводит сглаживание на нет. При телепортах вызывай setValue, чтобы следящий объект не гнался за целью со старого места.

Случайные числа

TypeScript
Mathf.random(min?, max?): number      // дробное в [min, max); по умолчанию 0..1
Mathf.randomInt(min, max): number     // целое, ВКЛЮЧАЯ оба конца

Смотрите также

  • Vec2 и Vec3 — векторные lerp / расстояние / нормализация живут на типах векторов
  • Соглашения — dt в секундах; правила «градусы против радианов»