@px-petals/roku.motion-web 0.0.0-stage → 1.1.0

package/script/luau/lib/math/math.js

@@ -0,0 +1,288 @@
+/**
+ * The `math` library, and `os`. Functions ES5 lacks (`sinh`, `log10`, `sign`,
+ * ...) are written out, because the oldest browsers this runs in lack them.
+ */
+
+import { LuaTable } from '../../vm/vm.value.js'
+import { sign, trunc } from '../../vm/vm.num.js'
+import { argError, checkInt, checkNumber, optNumber, register } from '../lib.args.js'
+
+/**
+ * @param   {number} x
+ * @returns {number}
+ */
+function sinh(x) {
+  return (Math.exp(x) - Math.exp(-x)) / 2
+}
+
+/**
+ * @param   {number} x
+ * @returns {number}
+ */
+function cosh(x) {
+  return (Math.exp(x) + Math.exp(-x)) / 2
+}
+
+/**
+ * @param   {number} x
+ * @returns {number}
+ */
+function tanh(x) {
+  if (x > 20) return 1
+  if (x < -20) return -1
+  const a = Math.exp(2 * x)
+  return (a - 1) / (a + 1)
+}
+
+/**
+ * The log of x in base `b`, exact where x is a power of b.
+ *
+ * @param   {number} x
+ * @param   {number} lnb  the natural log of the base
+ * @param   {number} b
+ * @returns {number}
+ */
+function logBase(x, lnb, b) {
+  const r = Math.log(x) / lnb
+  const rounded = Math.round(r)
+  return Math.abs(r - rounded) < 1e-9 && Math.pow(b, rounded) === x ? rounded : r
+}
+
+/**
+ * A small deterministic generator (mulberry32), 32 bits of state.
+ *
+ * @param {number} seed
+ */
+function makeRandom(seed) {
+  let state = seed >>> 0
+  return function () {
+    state = (state + 0x6d2b79f5) >>> 0
+    let t = state
+    t = Math.imul(t ^ (t >>> 15), t | 1)
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61)
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296
+  }
+}
+
+/**
+ * @param {import('../../vm/vm.js').VM} vm
+ * @param {LuaTable} G
+ */
+export function installMath(vm, G) {
+  const math = new LuaTable()
+  G.set('math', math)
+  let random = makeRandom(0x2545f491)
+
+  /**
+   * One-argument functions.
+   *
+   * @param {string} name
+   * @param {(x: number) => number} f
+   */
+  const unary = function (name, f) {
+    math.set(name, vm.native('math.' + name, function (vm2, args) {
+      return f(checkNumber(args, 0, name))
+    }))
+  }
+
+  unary('abs', Math.abs)
+  unary('acos', Math.acos)
+  unary('asin', Math.asin)
+  unary('atan', Math.atan)
+  unary('ceil', Math.ceil)
+  unary('cos', Math.cos)
+  unary('cosh', cosh)
+  unary('deg', function (x) { return x * (180 / Math.PI) })
+  unary('exp', Math.exp)
+  unary('floor', Math.floor)
+  unary('log10', function (x) { return logBase(x, Math.LN10, 10) })
+  unary('rad', function (x) { return x * (Math.PI / 180) })
+  unary('sin', Math.sin)
+  unary('sinh', sinh)
+  unary('sqrt', Math.sqrt)
+  unary('tan', Math.tan)
+  unary('tanh', tanh)
+  unary('sign', sign)
+  unary('round', function (x) { return x < 0 ? -Math.floor(-x + 0.5) : Math.floor(x + 0.5) })
+  unary('isnan', function (x) { return /** @type {any} */ (x !== x) })
+  unary('isinf', function (x) { return /** @type {any} */ (x === Infinity || x === -Infinity) })
+  unary('isfinite', function (x) { return /** @type {any} */ (x === x && x !== Infinity && x !== -Infinity) })
+
+  register(math, {
+    atan2(vm, args) {
+      return Math.atan2(checkNumber(args, 0, 'atan2'), checkNumber(args, 1, 'atan2'))
+    },
+
+    fmod(vm, args) {
+      return checkNumber(args, 0, 'fmod') % checkNumber(args, 1, 'fmod')
+    },
+
+    frexp(vm, args) {
+      const x = checkNumber(args, 0, 'frexp')
+      if (x === 0 || x !== x || x === Infinity || x === -Infinity) return [ x, 0 ]
+      let e = Math.max(-1023, Math.floor(logBase(Math.abs(x), Math.LN2, 2)) + 1)
+      let m = x * Math.pow(2, -e)
+      while (Math.abs(m) < 0.5) {
+        m *= 2
+        e--
+      }
+      while (Math.abs(m) >= 1) {
+        m /= 2
+        e++
+      }
+      return [ m, e ]
+    },
+
+    ldexp(vm, args) {
+      return checkNumber(args, 0, 'ldexp') * Math.pow(2, checkInt(args, 1, 'ldexp'))
+    },
+
+    log(vm, args) {
+      const x = checkNumber(args, 0, 'log')
+      if (args[1] === undefined) return Math.log(x)
+      const b = checkNumber(args, 1, 'log')
+      if (b === 2) return logBase(x, Math.LN2, 2)
+      if (b === 10) return logBase(x, Math.LN10, 10)
+      return Math.log(x) / Math.log(b)
+    },
+
+    max(vm, args) {
+      let m = checkNumber(args, 0, 'max')
+      for (let i = 1; i < args.length; i++) {
+        const v = checkNumber(args, i, 'max')
+        if (v > m) m = v
+      }
+      return m
+    },
+
+    min(vm, args) {
+      let m = checkNumber(args, 0, 'min')
+      for (let i = 1; i < args.length; i++) {
+        const v = checkNumber(args, i, 'min')
+        if (v < m) m = v
+      }
+      return m
+    },
+
+    modf(vm, args) {
+      const x = checkNumber(args, 0, 'modf')
+      const whole = trunc(x)
+      return [ whole, x - whole ]
+    },
+
+    pow(vm, args) {
+      return Math.pow(checkNumber(args, 0, 'pow'), checkNumber(args, 1, 'pow'))
+    },
+
+    clamp(vm, args) {
+      const v = checkNumber(args, 0, 'clamp')
+      const lo = checkNumber(args, 1, 'clamp')
+      const hi = checkNumber(args, 2, 'clamp')
+      if (lo > hi) throw argError(3, 'clamp', 'max must be greater than min')
+      return v < lo ? lo : v > hi ? hi : v
+    },
+
+    lerp(vm, args) {
+      const a = checkNumber(args, 0, 'lerp')
+      const b = checkNumber(args, 1, 'lerp')
+      const t = checkNumber(args, 2, 'lerp')
+      return t === 1 ? b : a + (b - a) * t
+    },
+
+    random(vm, args) {
+      const r = random()
+      if (args.length === 0) return r
+      const lo = args.length === 1 ? 1 : checkInt(args, 0, 'random')
+      const hi = checkInt(args, args.length === 1 ? 0 : 1, 'random')
+      if (lo > hi) throw argError(args.length === 1 ? 1 : 2, 'random', 'interval is empty')
+      return lo + Math.floor(r * (hi - lo + 1))
+    },
+
+    randomseed(vm, args) {
+      random = makeRandom(checkInt(args, 0, 'randomseed'))
+      return []
+    },
+
+    noise(vm, args) {
+      return noise(checkNumber(args, 0, 'noise'), optNumber(args, 1, 'noise', 0), optNumber(args, 2, 'noise', 0))
+    },
+  }, 'math.')
+
+  math.set('pi', Math.PI)
+  math.set('huge', Infinity)
+
+  // os
+  const os = new LuaTable()
+  G.set('os', os)
+  register(os, {
+    clock() {
+      return now() / 1000
+    },
+    time() {
+      return Math.floor(Date.now() / 1000)
+    },
+  }, 'os.')
+}
+
+/** @returns {number} milliseconds, from a clock that only moves forward where the host has one */
+function now() {
+  const perf = typeof performance !== 'undefined' ? performance : null
+  return perf !== null && typeof perf.now === 'function' ? perf.now() : Date.now()
+}
+
+/**
+ * Perlin gradient noise in 1 to 3 dimensions, in about -1..1.
+ *
+ * @param   {number} x
+ * @param   {number} y
+ * @param   {number} z
+ * @returns {number}
+ */
+function noise(x, y, z) {
+  const xi = Math.floor(x)
+  const yi = Math.floor(y)
+  const zi = Math.floor(z)
+  const xf = x - xi
+  const yf = y - yi
+  const zf = z - zi
+  /** @param {number} t */
+  const fade = function (t) { return t * t * t * (t * (t * 6 - 15) + 10) }
+  /**
+   * @param {number} a
+   * @param {number} b
+   * @param {number} c
+   */
+  const hash = function (a, b, c) {
+    let h = Math.imul(a, 374761393) + Math.imul(b, 668265263) + Math.imul(c, 1274126177)
+    h = Math.imul(h ^ (h >>> 13), 1274126177)
+    return (h ^ (h >>> 16)) & 15
+  }
+  /**
+   * @param {number} h
+   * @param {number} dx
+   * @param {number} dy
+   * @param {number} dz
+   */
+  const grad = function (h, dx, dy, dz) {
+    const u = h < 8 ? dx : dy
+    const v = h < 4 ? dy : h === 12 || h === 14 ? dx : dz
+    return ((h & 1) === 0 ? u : -u) + ((h & 2) === 0 ? v : -v)
+  }
+  const u = fade(xf)
+  const v = fade(yf)
+  const w = fade(zf)
+  /**
+   * @param {number} a
+   * @param {number} b
+   * @param {number} t
+   */
+  const lerp = function (a, b, t) { return a + (b - a) * t }
+  const c = function (/** @type {number} */ dx, /** @type {number} */ dy, /** @type {number} */ dz) {
+    return grad(hash(xi + dx, yi + dy, zi + dz), xf - dx, yf - dy, zf - dz)
+  }
+  return lerp(
+    lerp(lerp(c(0, 0, 0), c(1, 0, 0), u), lerp(c(0, 1, 0), c(1, 1, 0), u), v),
+    lerp(lerp(c(0, 0, 1), c(1, 0, 1), u), lerp(c(0, 1, 1), c(1, 1, 1), u), v),
+    w,
+  )
+}

package/script/luau/lib/math/math.vector.js

@@ -0,0 +1,125 @@
+/**
+ * The `vector` library: the three-component vector value's functions.
+ */
+
+import { LuaTable, Vector, fround } from '../../vm/vm.value.js'
+import { sign } from '../../vm/vm.num.js'
+import { checkNumber, register, typeError } from '../lib.args.js'
+
+/**
+ * @param   {any[]}  args
+ * @param   {number} i
+ * @param   {string} name
+ * @returns {Vector}
+ */
+function checkVector(args, i, name) {
+  const v = args[i]
+  if (!(v instanceof Vector)) throw typeError(args, i, name, 'vector')
+  return v
+}
+
+/**
+ * @param   {Vector} v
+ * @returns {number}
+ */
+function magnitude(v) {
+  return fround(Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z))
+}
+
+/**
+ * @param {import('../../vm/vm.js').VM} vm
+ * @param {LuaTable} G
+ */
+export function installVector(vm, G) {
+  const lib = new LuaTable()
+  G.set('vector', lib)
+
+  /**
+   * A function of one vector that maps each component.
+   *
+   * @param {string} name
+   * @param {(n: number) => number} f
+   */
+  const mapped = function (name, f) {
+    lib.set(name, vm.native('vector.' + name, function (vm2, args) {
+      const v = checkVector(args, 0, name)
+      return new Vector(f(v.x), f(v.y), f(v.z))
+    }))
+  }
+  mapped('floor', Math.floor)
+  mapped('ceil', Math.ceil)
+  mapped('abs', Math.abs)
+  mapped('sign', sign)
+
+  register(lib, {
+    create(vm, args) {
+      return new Vector(checkNumber(args, 0, 'create'), checkNumber(args, 1, 'create'), args[2] === undefined ? 0 : checkNumber(args, 2, 'create'))
+    },
+
+    magnitude(vm, args) {
+      return magnitude(checkVector(args, 0, 'magnitude'))
+    },
+
+    normalize(vm, args) {
+      const v = checkVector(args, 0, 'normalize')
+      const m = magnitude(v)
+      return new Vector(v.x / m, v.y / m, v.z / m)
+    },
+
+    dot(vm, args) {
+      const a = checkVector(args, 0, 'dot')
+      const b = checkVector(args, 1, 'dot')
+      return fround(a.x * b.x + a.y * b.y + a.z * b.z)
+    },
+
+    cross(vm, args) {
+      const a = checkVector(args, 0, 'cross')
+      const b = checkVector(args, 1, 'cross')
+      return new Vector(a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x)
+    },
+
+    angle(vm, args) {
+      const a = checkVector(args, 0, 'angle')
+      const b = checkVector(args, 1, 'angle')
+      const cx = a.y * b.z - a.z * b.y
+      const cy = a.z * b.x - a.x * b.z
+      const cz = a.x * b.y - a.y * b.x
+      return Math.atan2(Math.sqrt(cx * cx + cy * cy + cz * cz), a.x * b.x + a.y * b.y + a.z * b.z)
+    },
+
+    clamp(vm, args) {
+      const v = checkVector(args, 0, 'clamp')
+      const lo = checkVector(args, 1, 'clamp')
+      const hi = checkVector(args, 2, 'clamp')
+      return new Vector(Math.min(Math.max(v.x, lo.x), hi.x), Math.min(Math.max(v.y, lo.y), hi.y), Math.min(Math.max(v.z, lo.z), hi.z))
+    },
+
+    min(vm, args) {
+      let r = checkVector(args, 0, 'min')
+      for (let i = 1; i < args.length; i++) {
+        const v = checkVector(args, i, 'min')
+        r = new Vector(Math.min(r.x, v.x), Math.min(r.y, v.y), Math.min(r.z, v.z))
+      }
+      return r
+    },
+
+    max(vm, args) {
+      let r = checkVector(args, 0, 'max')
+      for (let i = 1; i < args.length; i++) {
+        const v = checkVector(args, i, 'max')
+        r = new Vector(Math.max(r.x, v.x), Math.max(r.y, v.y), Math.max(r.z, v.z))
+      }
+      return r
+    },
+
+    lerp(vm, args) {
+      const a = checkVector(args, 0, 'lerp')
+      const b = checkVector(args, 1, 'lerp')
+      const t = checkNumber(args, 2, 'lerp')
+      return new Vector(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t, a.z + (b.z - a.z) * t)
+    },
+  }, 'vector.')
+
+  lib.set('zero', new Vector(0, 0, 0))
+  lib.set('one', new Vector(1, 1, 1))
+}

package/script/luau/lib/string/string.format.js

@@ -0,0 +1,143 @@
+/**
+ * `string.format`: C's printf conversions as Lua uses them.
+ */
+
+import { fail } from '../../vm/vm.value.js'
+import { formatE, formatF, formatG, repeat, trunc } from '../../vm/vm.num.js'
+import { checkNumber, checkString } from '../lib.args.js'
+
+const SPEC = /^%([-+ #0]*)(\d*)(?:\.(\d*))?([a-zA-Z%])/
+
+/**
+ * Pads `body` (with its sign or prefix split off) to `width`.
+ *
+ * @param   {string}  sign   '-', '+', ' ', a `0x` prefix or ''
+ * @param   {string}  body
+ * @param   {number}  width
+ * @param   {string}  flags
+ * @param   {boolean} zeroOk  whether the 0 flag pads with zeros here
+ * @returns {string}
+ */
+function pad(sign, body, width, flags, zeroOk) {
+  const n = width - sign.length - body.length
+  if (n <= 0) return sign + body
+  if (flags.indexOf('-') >= 0) return sign + body + repeat(' ', n)
+  if (flags.indexOf('0') >= 0 && zeroOk) return sign + repeat('0', n) + body
+  return repeat(' ', n) + sign + body
+}
+
+/**
+ * @param   {string} s
+ * @returns {string} s as a Lua string literal that reads back as s (`%q`)
+ */
+function quote(s) {
+  let out = '"'
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i)
+    const ch = s.charAt(i)
+    if (ch === '"' || ch === '\\') out += '\\' + ch
+    else if (c === 10) out += '\\\n'
+    else if (c === 13) out += '\\r'
+    else if (c === 0) out += '\\000'
+    else out += ch
+  }
+  return out + '"'
+}
+
+/**
+ * @param   {import('../../vm/vm.js').VM} vm
+ * @param   {any[]} args  the format string, then the values
+ * @returns {string}
+ */
+export function format(vm, args) {
+  const fmt = checkString(args, 0, 'format')
+  let out = ''
+  let arg = 0
+  let i = 0
+  while (i < fmt.length) {
+    const pct = fmt.indexOf('%', i)
+    if (pct < 0) {
+      out += fmt.substring(i)
+      break
+    }
+    out += fmt.substring(i, pct)
+    const m = SPEC.exec(fmt.substring(pct))
+    if (m === null) throw fail("invalid option '%" + fmt.charAt(pct + 1) + "' to 'format'")
+    i = pct + m[0].length
+    const flags = m[1]
+    const width = m[2] === '' ? 0 : parseInt(m[2], 10)
+    const hasPrecision = m[3] !== undefined
+    const precision = hasPrecision ? (m[3] === '' ? 0 : parseInt(m[3], 10)) : -1
+    const conv = m[4]
+    if (conv === '%') {
+      out += '%'
+      continue
+    }
+    arg++
+    if (arg >= args.length) throw fail('missing argument #' + (arg + 1))
+    const signOf = function (/** @type {boolean} */ negative) {
+      return negative ? '-' : flags.indexOf('+') >= 0 ? '+' : flags.indexOf(' ') >= 0 ? ' ' : ''
+    }
+    switch (conv) {
+      case 'd':
+      case 'i':
+      case 'u': {
+        const n = trunc(checkNumber(args, arg, 'format'))
+        let body = String(Math.abs(n))
+        if (hasPrecision) while (body.length < precision) body = '0' + body
+        out += pad(signOf(n < 0), body, width, flags, !hasPrecision)
+        break
+      }
+      case 'c':
+        out += pad('', String.fromCharCode(trunc(checkNumber(args, arg, 'format')) & 255), width, flags, false)
+        break
+      case 'x':
+      case 'X':
+      case 'o': {
+        let n = trunc(checkNumber(args, arg, 'format'))
+        if (n < 0) n += 4294967296
+        let body = n.toString(conv === 'o' ? 8 : 16)
+        if (conv === 'X') body = body.toUpperCase()
+        if (hasPrecision) while (body.length < precision) body = '0' + body
+        const prefix = flags.indexOf('#') >= 0 && n !== 0 ? (conv === 'o' ? '0' : conv === 'x' ? '0x' : '0X') : ''
+        out += pad(prefix, body, width, flags, !hasPrecision)
+        break
+      }
+      case 'e':
+      case 'E':
+      case 'f':
+      case 'F':
+      case 'g':
+      case 'G': {
+        const n = checkNumber(args, arg, 'format')
+        const upper = conv === 'E' || conv === 'G' || conv === 'F'
+        const alt = flags.indexOf('#') >= 0
+        const finite = n === n && n !== Infinity && n !== -Infinity
+        const neg = n < 0 || (n === 0 && 1 / n < 0)
+        let body
+        if (!finite) body = n !== n ? 'nan' : 'inf'
+        else {
+          const p = hasPrecision ? precision : 6
+          const a = Math.abs(n)
+          const lower = conv.toLowerCase()
+          body = lower === 'e' ? formatE(a, p, alt) : lower === 'f' ? formatF(a, p, alt) : formatG(a, p, alt)
+        }
+        if (upper) body = body.toUpperCase()
+        out += pad(signOf(neg), body, width, flags, finite)
+        break
+      }
+      case 'q':
+        out += quote(checkString(args, arg, 'format'))
+        break
+      case 's': {
+        let s = checkString(args, arg, 'format')
+        if (hasPrecision) s = s.substring(0, precision)
+        out += pad('', s, width, flags, false)
+        break
+      }
+      default:
+        throw fail("invalid option '%" + conv + "' to 'format'")
+    }
+  }
+  return out
+}