aether-physics 0.0.0-stage → 0.2.0

package/dist/math-DrI-pge3.js

@@ -0,0 +1,502 @@
+//#region src/math/scalar.ts
+var e = 1e-6;
+function t(t, n, r = e) {
+	if (t === n) return !0;
+	let i = Math.abs(t - n);
+	return Number.isFinite(i) && i <= r * Math.max(1, Math.abs(t), Math.abs(n));
+}
+function n(e, t, n) {
+	return e < t ? t : e > n ? n : e;
+}
+//#endregion
+//#region src/math/geometry/vec3.ts
+var r = class n {
+	x;
+	y;
+	z;
+	constructor(e = 0, t = 0, n = 0) {
+		this.x = e, this.y = t, this.z = n;
+	}
+	set(e, t, n) {
+		return this.x = e, this.y = t, this.z = n, this;
+	}
+	copy(e) {
+		return this.x = e.x, this.y = e.y, this.z = e.z, this;
+	}
+	clone() {
+		return new n(this.x, this.y, this.z);
+	}
+	magnitude() {
+		return Math.sqrt(this.magnitudeSquared());
+	}
+	magnitudeSquared() {
+		return this.x * this.x + this.y * this.y + this.z * this.z;
+	}
+	distanceTo(e) {
+		return Math.sqrt(this.distanceToSquared(e));
+	}
+	distanceToSquared(e) {
+		let t = this.x - e.x, n = this.y - e.y, r = this.z - e.z;
+		return t * t + n * n + r * r;
+	}
+	add(e) {
+		return this.x += e.x, this.y += e.y, this.z += e.z, this;
+	}
+	subtract(e) {
+		return this.x -= e.x, this.y -= e.y, this.z -= e.z, this;
+	}
+	scale(e) {
+		return this.x *= e, this.y *= e, this.z *= e, this;
+	}
+	addScaled(e, t) {
+		return this.x += e.x * t, this.y += e.y * t, this.z += e.z * t, this;
+	}
+	componentWiseProduct(e) {
+		return this.x *= e.x, this.y *= e.y, this.z *= e.z, this;
+	}
+	negate() {
+		return this.x = -this.x, this.y = -this.y, this.z = -this.z, this;
+	}
+	lerp(e, t) {
+		return this.x += (e.x - this.x) * t, this.y += (e.y - this.y) * t, this.z += (e.z - this.z) * t, this;
+	}
+	equals(n, r = e) {
+		return t(this.x, n.x, r) && t(this.y, n.y, r) && t(this.z, n.z, r);
+	}
+	dot(e) {
+		return this.x * e.x + this.y * e.y + this.z * e.z;
+	}
+	cross(e) {
+		return this.crossVectors(this, e);
+	}
+	crossVectors(e, t) {
+		let n = e.x, r = e.y, i = e.z, a = t.x, o = t.y, s = t.z;
+		return this.x = r * s - i * o, this.y = i * a - n * s, this.z = n * o - r * a, this;
+	}
+	static cross(e, t) {
+		return new n(e.y * t.z - e.z * t.y, e.z * t.x - e.x * t.z, e.x * t.y - e.y * t.x);
+	}
+	normalize() {
+		let e = this.magnitude();
+		return e > 0 ? (this.x /= e, this.y /= e, this.z /= e) : (this.x = 0, this.y = 0, this.z = 0), this;
+	}
+}, i = new Float64Array([
+	1,
+	0,
+	0,
+	0,
+	1,
+	0,
+	0,
+	0,
+	1
+]), a = class e {
+	elements;
+	constructor(e = 1, t = 0, n = 0, r = 0, i = 1, a = 0, o = 0, s = 0, c = 1) {
+		this.elements = new Float64Array([
+			e,
+			t,
+			n,
+			r,
+			i,
+			a,
+			o,
+			s,
+			c
+		]);
+	}
+	identity() {
+		return this.elements.set(i), this;
+	}
+	copy(e) {
+		return this.elements.set(e.elements), this;
+	}
+	clone() {
+		return new e().copy(this);
+	}
+	setDiagonal(e, t, n) {
+		let r = this.elements;
+		return r[0] = e, r[1] = 0, r[2] = 0, r[3] = 0, r[4] = t, r[5] = 0, r[6] = 0, r[7] = 0, r[8] = n, this;
+	}
+	setScale(e, t = e, n = e) {
+		return this.setDiagonal(e, t, n);
+	}
+	setScaleAlongAxis(e, t) {
+		let n = this.elements, r = e.x, i = e.y, a = e.z, o = t - 1;
+		return n[0] = 1 + o * r * r, n[1] = o * r * i, n[2] = o * r * a, n[3] = o * r * i, n[4] = 1 + o * i * i, n[5] = o * i * a, n[6] = o * r * a, n[7] = o * i * a, n[8] = 1 + o * a * a, this;
+	}
+	setReflection(e) {
+		return this.setScaleAlongAxis(e, -1);
+	}
+	setShear(e = 0, t = 0, n = 0, r = 0, i = 0, a = 0) {
+		let o = this.elements;
+		return o[0] = 1, o[1] = e, o[2] = t, o[3] = n, o[4] = 1, o[5] = r, o[6] = i, o[7] = a, o[8] = 1, this;
+	}
+	multiplyScalar(e) {
+		let t = this.elements;
+		return t[0] = e * t[0], t[1] = e * t[1], t[2] = e * t[2], t[3] = e * t[3], t[4] = e * t[4], t[5] = e * t[5], t[6] = e * t[6], t[7] = e * t[7], t[8] = e * t[8], this;
+	}
+	multiply(e) {
+		return this.multiplyMatrices(this, e);
+	}
+	premultiply(e) {
+		return this.multiplyMatrices(e, this);
+	}
+	multiplyMatrices(e, t) {
+		let n = e.elements, r = t.elements, i = n[0], a = n[1], o = n[2], s = n[3], c = n[4], l = n[5], u = n[6], d = n[7], f = n[8], p = r[0], m = r[1], h = r[2], g = r[3], _ = r[4], v = r[5], y = r[6], b = r[7], x = r[8], S = this.elements;
+		return S[0] = i * p + a * g + o * y, S[1] = i * m + a * _ + o * b, S[2] = i * h + a * v + o * x, S[3] = s * p + c * g + l * y, S[4] = s * m + c * _ + l * b, S[5] = s * h + c * v + l * x, S[6] = u * p + d * g + f * y, S[7] = u * m + d * _ + f * b, S[8] = u * h + d * v + f * x, this;
+	}
+	transpose() {
+		let e = this.elements, t = e[1], n = e[2], r = e[3], i = e[5], a = e[6], o = e[7];
+		return e[1] = r, e[2] = a, e[3] = t, e[5] = o, e[6] = n, e[7] = i, this;
+	}
+	determinant() {
+		let e = this.elements, t = e[0], n = e[1], r = e[2], i = e[3], a = e[4], o = e[5], s = e[6], c = e[7], l = e[8];
+		return t * (a * l - o * c) + n * (o * s - i * l) + r * (i * c - a * s);
+	}
+	setInverse(e) {
+		let t = e.elements, n = t[0], r = t[1], i = t[2], a = t[3], o = t[4], s = t[5], c = t[6], l = t[7], u = t[8], d = o * u - s * l, f = s * c - a * u, p = a * l - o * c, m = n * d + r * f + i * p, h = this.elements;
+		if (m === 0) return h.fill(0), this;
+		let g = 1 / m;
+		return h[0] = d * g, h[1] = (i * l - r * u) * g, h[2] = (r * s - i * o) * g, h[3] = f * g, h[4] = (n * u - i * c) * g, h[5] = (i * a - n * s) * g, h[6] = p * g, h[7] = (r * c - n * l) * g, h[8] = (n * o - r * a) * g, this;
+	}
+	inverse() {
+		return this.setInverse(this);
+	}
+	setInverseOrthonormal(e) {
+		let t = e.elements, n = t[0], r = t[1], i = t[2], a = t[3], o = t[4], s = t[5], c = t[6], l = t[7], u = t[8], d = this.elements;
+		return d[0] = n, d[1] = a, d[2] = c, d[3] = r, d[4] = o, d[5] = l, d[6] = i, d[7] = s, d[8] = u, this;
+	}
+	inverseOrthonormal() {
+		return this.transpose();
+	}
+	transformVec3(e, t = new r()) {
+		let n = this.elements, i = e.x, a = e.y, o = e.z;
+		return t.x = n[0] * i + n[1] * a + n[2] * o, t.y = n[3] * i + n[4] * a + n[5] * o, t.z = n[6] * i + n[7] * a + n[8] * o, t;
+	}
+	transformInverseVec3(e, t = new r()) {
+		let n = this.elements, i = e.x, a = e.y, o = e.z;
+		return t.x = n[0] * i + n[3] * a + n[6] * o, t.y = n[1] * i + n[4] * a + n[7] * o, t.z = n[2] * i + n[5] * a + n[8] * o, t;
+	}
+	setRotationX(e) {
+		let t = this.elements, n = Math.sin(e), r = Math.cos(e);
+		return t[0] = 1, t[1] = 0, t[2] = 0, t[3] = 0, t[4] = r, t[5] = -n, t[6] = 0, t[7] = n, t[8] = r, this;
+	}
+	setRotationY(e) {
+		let t = this.elements, n = Math.sin(e), r = Math.cos(e);
+		return t[0] = r, t[1] = 0, t[2] = n, t[3] = 0, t[4] = 1, t[5] = 0, t[6] = -n, t[7] = 0, t[8] = r, this;
+	}
+	setRotationZ(e) {
+		let t = this.elements, n = Math.sin(e), r = Math.cos(e);
+		return t[0] = r, t[1] = -n, t[2] = 0, t[3] = n, t[4] = r, t[5] = 0, t[6] = 0, t[7] = 0, t[8] = 1, this;
+	}
+	setFromAxisAngle(e, t) {
+		let n = e.x, r = e.y, i = e.z, a = Math.cos(t), o = Math.sin(t), s = this.elements, c = 1 - a;
+		return s[0] = c * n * n + a, s[1] = n * r * c - i * o, s[2] = n * i * c + r * o, s[3] = n * r * c + i * o, s[4] = a + r * r * c, s[5] = r * i * c - n * o, s[6] = n * i * c - r * o, s[7] = r * i * c + n * o, s[8] = a + i * i * c, this;
+	}
+	setFromQuaternion(e) {
+		let t = e.w, n = e.x, r = e.y, i = e.z, a = n + n, o = r + r, s = i + i, c = n * a, l = r * o, u = i * s, d = n * o, f = n * s, p = r * s, m = t * a, h = t * o, g = t * s, _ = this.elements;
+		return _[0] = 1 - (l + u), _[1] = d - g, _[2] = f + h, _[3] = d + g, _[4] = 1 - (c + u), _[5] = p - m, _[6] = f - h, _[7] = p + m, _[8] = 1 - (c + l), this;
+	}
+}, o = new Float64Array([
+	1,
+	0,
+	0,
+	0,
+	0,
+	1,
+	0,
+	0,
+	0,
+	0,
+	1,
+	0
+]), s = class e {
+	elements;
+	constructor(e = 1, t = 0, n = 0, r = 0, i = 0, a = 1, o = 0, s = 0, c = 0, l = 0, u = 1, d = 0) {
+		this.elements = new Float64Array([
+			e,
+			t,
+			n,
+			r,
+			i,
+			a,
+			o,
+			s,
+			c,
+			l,
+			u,
+			d
+		]);
+	}
+	identity() {
+		return this.elements.set(o), this;
+	}
+	copy(e) {
+		return this.elements.set(e.elements), this;
+	}
+	clone() {
+		return new e().copy(this);
+	}
+	setFromMat3x3(e, t = {
+		x: 0,
+		y: 0,
+		z: 0
+	}) {
+		let n = this.elements, r = e.elements;
+		return n[0] = r[0], n[1] = r[1], n[2] = r[2], n[3] = t.x, n[4] = r[3], n[5] = r[4], n[6] = r[5], n[7] = t.y, n[8] = r[6], n[9] = r[7], n[10] = r[8], n[11] = t.z, this;
+	}
+	getMat3x3(e = new a()) {
+		let t = this.elements, n = e.elements;
+		return n[0] = t[0], n[1] = t[1], n[2] = t[2], n[3] = t[4], n[4] = t[5], n[5] = t[6], n[6] = t[8], n[7] = t[9], n[8] = t[10], e;
+	}
+	setTranslation(e, t, n) {
+		this.elements.set(o);
+		let r = this.elements;
+		return r[3] = e, r[7] = t, r[11] = n, this;
+	}
+	getTranslation(e = new r()) {
+		let t = this.elements;
+		return e.x = t[3], e.y = t[7], e.z = t[11], e;
+	}
+	getAxis(e, t = new r()) {
+		let n = this.elements;
+		return t.x = n[e], t.y = n[e + 4], t.z = n[e + 8], t;
+	}
+	setFromPositionQuaternion(e, t) {
+		let n = t.w, r = t.x, i = t.y, a = t.z, o = r + r, s = i + i, c = a + a, l = r * o, u = i * s, d = a * c, f = r * s, p = r * c, m = i * c, h = n * o, g = n * s, _ = n * c, v = this.elements;
+		return v[0] = 1 - (u + d), v[1] = f - _, v[2] = p + g, v[3] = e.x, v[4] = f + _, v[5] = 1 - (l + d), v[6] = m - h, v[7] = e.y, v[8] = p - g, v[9] = m + h, v[10] = 1 - (l + u), v[11] = e.z, this;
+	}
+	setScale(e, t = e, n = e) {
+		let r = this.elements;
+		return r[0] = e, r[1] = 0, r[2] = 0, r[3] = 0, r[4] = 0, r[5] = t, r[6] = 0, r[7] = 0, r[8] = 0, r[9] = 0, r[10] = n, r[11] = 0, this;
+	}
+	setScaleAlongAxis(e, t) {
+		let n = this.elements, r = e.x, i = e.y, a = e.z, o = t - 1;
+		return n[0] = 1 + o * r * r, n[1] = o * r * i, n[2] = o * r * a, n[3] = 0, n[4] = o * r * i, n[5] = 1 + o * i * i, n[6] = o * i * a, n[7] = 0, n[8] = o * r * a, n[9] = o * i * a, n[10] = 1 + o * a * a, n[11] = 0, this;
+	}
+	setReflection(e) {
+		return this.setScaleAlongAxis(e, -1);
+	}
+	setShear(e = 0, t = 0, n = 0, r = 0, i = 0, a = 0) {
+		let o = this.elements;
+		return o[0] = 1, o[1] = e, o[2] = t, o[3] = 0, o[4] = n, o[5] = 1, o[6] = r, o[7] = 0, o[8] = i, o[9] = a, o[10] = 1, o[11] = 0, this;
+	}
+	multiplyScalar(e) {
+		let t = this.elements;
+		return t[0] = e * t[0], t[1] = e * t[1], t[2] = e * t[2], t[3] = e * t[3], t[4] = e * t[4], t[5] = e * t[5], t[6] = e * t[6], t[7] = e * t[7], t[8] = e * t[8], t[9] = e * t[9], t[10] = e * t[10], t[11] = e * t[11], this;
+	}
+	multiply(e) {
+		return this.multiplyMatrices(this, e);
+	}
+	premultiply(e) {
+		return this.multiplyMatrices(e, this);
+	}
+	multiplyMatrices(e, t) {
+		let n = e.elements, r = t.elements, i = n[0], a = n[1], o = n[2], s = n[3], c = n[4], l = n[5], u = n[6], d = n[7], f = n[8], p = n[9], m = n[10], h = n[11], g = r[0], _ = r[1], v = r[2], y = r[3], b = r[4], x = r[5], S = r[6], C = r[7], w = r[8], T = r[9], E = r[10], D = r[11], O = this.elements;
+		return O[0] = i * g + a * b + o * w, O[1] = i * _ + a * x + o * T, O[2] = i * v + a * S + o * E, O[3] = i * y + a * C + o * D + s, O[4] = c * g + l * b + u * w, O[5] = c * _ + l * x + u * T, O[6] = c * v + l * S + u * E, O[7] = c * y + l * C + u * D + d, O[8] = f * g + p * b + m * w, O[9] = f * _ + p * x + m * T, O[10] = f * v + p * S + m * E, O[11] = f * y + p * C + m * D + h, this;
+	}
+	transposeLinear() {
+		let e = this.elements, t = e[1], n = e[2], r = e[4], i = e[6], a = e[8], o = e[9];
+		return e[1] = r, e[2] = a, e[4] = t, e[6] = o, e[8] = n, e[9] = i, this;
+	}
+	determinant() {
+		let e = this.elements, t = e[0], n = e[1], r = e[2], i = e[4], a = e[5], o = e[6], s = e[8], c = e[9], l = e[10];
+		return t * (a * l - o * c) + n * (o * s - i * l) + r * (i * c - a * s);
+	}
+	setInverse(e) {
+		let t = e.elements, n = t[0], r = t[1], i = t[2], a = t[3], o = t[4], s = t[5], c = t[6], l = t[7], u = t[8], d = t[9], f = t[10], p = t[11], m = s * f - c * d, h = c * u - o * f, g = o * d - s * u, _ = n * m + r * h + i * g, v = this.elements;
+		if (_ === 0) return v.fill(0), this;
+		let y = 1 / _, b = m * y, x = (i * d - r * f) * y, S = (r * c - i * s) * y, C = h * y, w = (n * f - i * u) * y, T = (i * o - n * c) * y, E = g * y, D = (r * u - n * d) * y, O = (n * s - r * o) * y;
+		return v[0] = b, v[1] = x, v[2] = S, v[3] = -(b * a + x * l + S * p), v[4] = C, v[5] = w, v[6] = T, v[7] = -(C * a + w * l + T * p), v[8] = E, v[9] = D, v[10] = O, v[11] = -(E * a + D * l + O * p), this;
+	}
+	inverse() {
+		return this.setInverse(this);
+	}
+	setInverseOrthonormal(e) {
+		let t = e.elements, n = t[0], r = t[1], i = t[2], a = t[3], o = t[4], s = t[5], c = t[6], l = t[7], u = t[8], d = t[9], f = t[10], p = t[11], m = this.elements;
+		return m[0] = n, m[1] = o, m[2] = u, m[3] = -(n * a + o * l + u * p), m[4] = r, m[5] = s, m[6] = d, m[7] = -(r * a + s * l + d * p), m[8] = i, m[9] = c, m[10] = f, m[11] = -(i * a + c * l + f * p), this;
+	}
+	inverseOrthonormal() {
+		return this.setInverseOrthonormal(this);
+	}
+	transformPoint(e, t = new r()) {
+		let n = this.elements, i = e.x, a = e.y, o = e.z;
+		return t.x = n[0] * i + n[1] * a + n[2] * o + n[3], t.y = n[4] * i + n[5] * a + n[6] * o + n[7], t.z = n[8] * i + n[9] * a + n[10] * o + n[11], t;
+	}
+	transformDirection(e, t = new r()) {
+		let n = this.elements, i = e.x, a = e.y, o = e.z;
+		return t.x = n[0] * i + n[1] * a + n[2] * o, t.y = n[4] * i + n[5] * a + n[6] * o, t.z = n[8] * i + n[9] * a + n[10] * o, t;
+	}
+	transformInversePoint(e, t = new r()) {
+		let n = this.elements, i = e.x - n[3], a = e.y - n[7], o = e.z - n[11];
+		return t.x = n[0] * i + n[4] * a + n[8] * o, t.y = n[1] * i + n[5] * a + n[9] * o, t.z = n[2] * i + n[6] * a + n[10] * o, t;
+	}
+	transformInverseDirection(e, t = new r()) {
+		let n = this.elements, i = e.x, a = e.y, o = e.z;
+		return t.x = n[0] * i + n[4] * a + n[8] * o, t.y = n[1] * i + n[5] * a + n[9] * o, t.z = n[2] * i + n[6] * a + n[10] * o, t;
+	}
+	setRotationX(e) {
+		let t = this.elements, n = Math.sin(e), r = Math.cos(e);
+		return t[0] = 1, t[1] = 0, t[2] = 0, t[3] = 0, t[4] = 0, t[5] = r, t[6] = -n, t[7] = 0, t[8] = 0, t[9] = n, t[10] = r, t[11] = 0, this;
+	}
+	setRotationY(e) {
+		let t = this.elements, n = Math.sin(e), r = Math.cos(e);
+		return t[0] = r, t[1] = 0, t[2] = n, t[3] = 0, t[4] = 0, t[5] = 1, t[6] = 0, t[7] = 0, t[8] = -n, t[9] = 0, t[10] = r, t[11] = 0, this;
+	}
+	setRotationZ(e) {
+		let t = this.elements, n = Math.sin(e), r = Math.cos(e);
+		return t[0] = r, t[1] = -n, t[2] = 0, t[3] = 0, t[4] = n, t[5] = r, t[6] = 0, t[7] = 0, t[8] = 0, t[9] = 0, t[10] = 1, t[11] = 0, this;
+	}
+	setFromAxisAngle(e, t) {
+		let n = e.x, r = e.y, i = e.z, a = Math.cos(t), o = Math.sin(t), s = this.elements, c = 1 - a;
+		return s[0] = c * n * n + a, s[1] = n * r * c - i * o, s[2] = n * i * c + r * o, s[3] = 0, s[4] = n * r * c + i * o, s[5] = a + r * r * c, s[6] = r * i * c - n * o, s[7] = 0, s[8] = n * i * c - r * o, s[9] = r * i * c + n * o, s[10] = a + i * i * c, s[11] = 0, this;
+	}
+}, c = .9999, l = 1e-12, u = .9999999, d = class n {
+	w;
+	x;
+	y;
+	z;
+	constructor(e = 1, t = 0, n = 0, r = 0) {
+		this.w = e, this.x = t, this.y = n, this.z = r;
+	}
+	identity() {
+		return this.w = 1, this.x = 0, this.y = 0, this.z = 0, this;
+	}
+	set(e, t, n, r) {
+		return this.w = e, this.x = t, this.y = n, this.z = r, this;
+	}
+	equals(n, r = e) {
+		return t(this.w, n.w, r) && t(this.x, n.x, r) && t(this.y, n.y, r) && t(this.z, n.z, r);
+	}
+	equalsRotation(n, r = e) {
+		let i = this.dot(n) < 0 ? -1 : 1;
+		return t(this.w, i * n.w, r) && t(this.x, i * n.x, r) && t(this.y, i * n.y, r) && t(this.z, i * n.z, r);
+	}
+	copy(e) {
+		return this.w = e.w, this.x = e.x, this.y = e.y, this.z = e.z, this;
+	}
+	clone() {
+		return new n(this.w, this.x, this.y, this.z);
+	}
+	magnitudeSquared() {
+		return this.w * this.w + this.x * this.x + this.y * this.y + this.z * this.z;
+	}
+	magnitude() {
+		return Math.sqrt(this.magnitudeSquared());
+	}
+	normalize() {
+		let e = this.magnitude();
+		return e === 0 ? this.identity() : (this.w /= e, this.x /= e, this.y /= e, this.z /= e, this);
+	}
+	scale(e) {
+		return this.w *= e, this.x *= e, this.y *= e, this.z *= e, this;
+	}
+	dot(e) {
+		return this.w * e.w + this.x * e.x + this.y * e.y + this.z * e.z;
+	}
+	conjugate() {
+		return this.x = -this.x, this.y = -this.y, this.z = -this.z, this;
+	}
+	inverse() {
+		let e = this.magnitudeSquared();
+		if (e === 0) return this;
+		let t = 1 / e;
+		return this.w *= t, this.x *= -t, this.y *= -t, this.z *= -t, this;
+	}
+	log() {
+		let e = this.w, t = this.x, n = this.y, r = this.z, i = t * t + n * n + r * r, a = Math.sqrt(i);
+		if (this.w = .5 * Math.log(e * e + i), a === 0) return this.x = e < 0 ? Math.PI : 0, this.y = 0, this.z = 0, this;
+		let o = Math.atan2(a, e) / a;
+		return this.x = o * t, this.y = o * n, this.z = o * r, this;
+	}
+	exp() {
+		let e = this.x, t = this.y, n = this.z, r = Math.sqrt(e * e + t * t + n * n), i = Math.exp(this.w), a = r === 0 ? i : i * Math.sin(r) / r;
+		return this.w = i * Math.cos(r), this.x = a * e, this.y = a * t, this.z = a * n, this;
+	}
+	multiply(e) {
+		return this.multiplyQuaternions(this, e);
+	}
+	premultiply(e) {
+		return this.multiplyQuaternions(e, this);
+	}
+	multiplyQuaternions(e, t) {
+		let n = e.w, r = e.x, i = e.y, a = e.z, o = t.w, s = t.x, c = t.y, l = t.z;
+		return this.w = n * o - (r * s + i * c + a * l), this.x = n * s + o * r + (i * l - a * c), this.y = n * c + o * i + (a * s - r * l), this.z = n * l + o * a + (r * c - i * s), this;
+	}
+	setFromAxisAngle(e, t) {
+		let n = e.x, r = e.y, i = e.z, a = Math.sqrt(n * n + r * r + i * i);
+		if (a === 0) return this.identity();
+		let o = t / 2, s = Math.sin(o) / a;
+		return this.w = Math.cos(o), this.x = s * n, this.y = s * r, this.z = s * i, this;
+	}
+	setToDifferenceQuaternion(e) {
+		let t = e.w, n = e.x, r = e.y, i = e.z, a = t * t + n * n + r * r + i * i, o = a === 0 ? 0 : 1 / a, s = t * o, c = -n * o, l = -r * o, u = -i * o, d = this.w, f = this.x, p = this.y, m = this.z;
+		return this.w = s * d - (c * f + l * p + u * m), this.x = s * f + d * c + (l * m - u * p), this.y = s * p + d * l + (u * f - c * m), this.z = s * m + d * u + (c * p - l * f), this;
+	}
+	rotateVec3(e, t = new r()) {
+		let n = this.w, i = this.x, a = this.y, o = this.z, s = e.x, c = e.y, l = e.z, u = 2 * (a * l - o * c), d = 2 * (o * s - i * l), f = 2 * (i * c - a * s);
+		return t.x = s + n * u + (a * f - o * d), t.y = c + n * d + (o * u - i * f), t.z = l + n * f + (i * d - a * u), t;
+	}
+	inverseRotateVec3(e, t = new r()) {
+		let n = this.w, i = this.x, a = this.y, o = this.z, s = e.x, c = e.y, l = e.z, u = 2 * (o * c - a * l), d = 2 * (i * l - o * s), f = 2 * (a * s - i * c);
+		return t.x = s + n * u - (a * f - o * d), t.y = c + n * d - (o * u - i * f), t.z = l + n * f - (i * d - a * u), t;
+	}
+	slerp(e, t) {
+		return this.slerpQuaternions(this, e, t);
+	}
+	slerpQuaternions(e, t, n) {
+		let r = e.w, i = e.x, a = e.y, o = e.z, s = t.w, l = t.x, u = t.y, d = t.z, f = r * s + i * l + a * u + o * d;
+		if (f < 0 && (s = -s, l = -l, u = -u, d = -d, f = -f), f > c) {
+			let e = 1 - n;
+			return this.w = e * r + n * s, this.x = e * i + n * l, this.y = e * a + n * u, this.z = e * o + n * d, this.normalize();
+		}
+		let p = Math.sqrt(1 - f * f), m = Math.atan2(p, f), h = 1 / p, g = Math.sin((1 - n) * m) * h, _ = Math.sin(n * m) * h;
+		return this.w = g * r + _ * s, this.x = g * i + _ * l, this.y = g * a + _ * u, this.z = g * o + _ * d, this;
+	}
+	addScaledAngularVelocity(e, t) {
+		let n = .5 * t, r = e.x * n, i = e.y * n, a = e.z * n, o = this.w, s = this.x, c = this.y, l = this.z;
+		return this.w = o - (r * s + i * c + a * l), this.x = s + o * r + (i * l - a * c), this.y = c + o * i + (a * s - r * l), this.z = l + o * a + (r * c - i * s), this;
+	}
+	setFromRotationMatrix(e) {
+		let t = e.elements, n = t[0], r = t[1], i = t[2], a = t[3], o = t[4], s = t[5], c = t[6], l = t[7], u = t[8], d = n + o + u;
+		if (d > 0) {
+			let e = 2 * Math.sqrt(d + 1);
+			this.w = .25 * e, this.x = (l - s) / e, this.y = (i - c) / e, this.z = (a - r) / e;
+		} else if (n > o && n > u) {
+			let e = 2 * Math.sqrt(1 + n - o - u);
+			this.w = (l - s) / e, this.x = .25 * e, this.y = (r + a) / e, this.z = (i + c) / e;
+		} else if (o > u) {
+			let e = 2 * Math.sqrt(1 + o - n - u);
+			this.w = (i - c) / e, this.x = (r + a) / e, this.y = .25 * e, this.z = (s + l) / e;
+		} else {
+			let e = 2 * Math.sqrt(1 + u - n - o);
+			this.w = (a - r) / e, this.x = (i + c) / e, this.y = (s + l) / e, this.z = .25 * e;
+		}
+		return this;
+	}
+	getAxisAngle(e = new r()) {
+		let t = this.w, n = this.x, i = this.y, a = this.z, o = Math.sqrt(n * n + i * i + a * a);
+		if (o === 0) return e.x = 1, e.y = 0, e.z = 0, 0;
+		let s = (t < 0 ? -1 : 1) / o;
+		return e.x = s * n, e.y = s * i, e.z = s * a, 2 * Math.atan2(o, Math.abs(t));
+	}
+	angleTo(e) {
+		let t = this.w, n = this.x, r = this.y, i = this.z, a = e.w, o = e.x, s = e.y, c = e.z, l = t * a + n * o + r * s + i * c, u = t * o - a * n - (r * c - i * s), d = t * s - a * r - (i * o - n * c), f = t * c - a * i - (n * s - r * o);
+		return 2 * Math.atan2(Math.sqrt(u * u + d * d + f * f), Math.abs(l));
+	}
+	setFromEulerXYZ(e, t, n) {
+		let r = Math.cos(e / 2), i = Math.sin(e / 2), a = Math.cos(t / 2), o = Math.sin(t / 2), s = Math.cos(n / 2), c = Math.sin(n / 2);
+		return this.w = r * a * s - i * o * c, this.x = i * a * s + r * o * c, this.y = r * o * s - i * a * c, this.z = r * a * c + i * o * s, this;
+	}
+	getEulerXYZ(e = new r()) {
+		let t = this.w, n = this.x, i = this.y, a = this.z, o = 1 - 2 * (i * i + a * a), s = 2 * (n * i - t * a), c = 2 * (n * a + t * i), l = 1 - 2 * (n * n + a * a), d = 2 * (i * a - t * n), f = 2 * (i * a + t * n), p = 1 - 2 * (n * n + i * i);
+		return e.y = Math.asin(Math.min(1, Math.max(-1, c))), Math.abs(c) < u ? (e.x = Math.atan2(-d, p), e.z = Math.atan2(-s, o)) : (e.x = Math.atan2(f, l), e.z = 0), e;
+	}
+	setFromUnitVectors(e, t) {
+		let n = e.x, r = e.y, i = e.z, a = t.x, o = t.y, s = t.z, c = 1 + (n * a + r * o + i * s);
+		return c < l ? (Math.abs(n) > Math.abs(i) ? (this.w = 0, this.x = -r, this.y = n, this.z = 0) : (this.w = 0, this.x = 0, this.y = -i, this.z = r), this.normalize()) : (this.w = c, this.x = r * s - i * o, this.y = i * a - n * s, this.z = n * o - r * a, this.normalize());
+	}
+};
+//#endregion
+export { e as a, r as i, s as n, t as o, a as r, n as s, d as t };

package/dist/math.js

@@ -0,0 +1 @@
+export { a as EPSILON, r as Mat3x3, n as Mat3x4, t as Quaternion, i as Vec3, o as approxEqual, s as clamp } from "./math-DrI-pge3.js";

package/dist/types/engine/index.d.ts

@@ -0,0 +1,4 @@
+export { FixedStepLoop } from "./loop.js";
+export type { FrameResult } from "./loop.js";
+export { Particle } from "./particle.js";
+export { ParticleWorld } from "./particle-world.js";

package/dist/types/engine/loop.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Fixed-timestep simulation clock with an accumulator.
+ *
+ * @see https://gafferongames.com/post/fix_your_timestep/
+ */
+export interface FrameResult {
+    /** Number of steps run. */
+    steps: number;
+    /** Interpolation factor in [0, 1) between the previous and current state. 1 while paused. */
+    alpha: number;
+    /** Whether accumulated time was discarded after reaching `maxStepsPerFrame`. */
+    droppedTime: boolean;
+}
+export declare class FixedStepLoop {
+    #private;
+    /** Simulation speed relative to real time. */
+    timeScale: number;
+    paused: boolean;
+    maxStepsPerFrame: number;
+    constructor(hz?: number);
+    /** Seconds per physics step. */
+    get dt(): number;
+    get hz(): number;
+    set hz(value: number);
+    /** Simulated time in seconds since the last reset. */
+    get simTime(): number;
+    /** Queues one step for the next `advance` call, regardless of `paused`. */
+    stepOnce(): void;
+    reset(): void;
+    /**
+     * Advances the clock and runs `step` once per elapsed timestep.
+     *
+     * @param nowMs - Current timestamp in milliseconds.
+     * @param step - Called with the fixed timestep in seconds.
+     */
+    advance(nowMs: number, step: (dt: number) => void): FrameResult;
+}

package/dist/types/engine/particle-world.d.ts

@@ -0,0 +1,13 @@
+import type { Particle } from "./particle.js";
+/** A collection of particles stepped together. */
+export declare class ParticleWorld {
+    /** Particles in this world, integrated in array order. Add and remove them directly. */
+    readonly particles: Particle[];
+    /**
+     * Integrates every particle by one step.
+     *
+     * @param dt Step length in seconds.
+     * @throws RangeError If `dt` is not positive and the world has particles.
+     */
+    step(dt: number): void;
+}

package/dist/types/engine/particle.d.ts

@@ -0,0 +1,51 @@
+import { Vec3, type Vec3Like } from "../math/index.js";
+/**
+ * A point mass integrated with semi-implicit Euler.
+ *
+ * Mass is stored as its inverse, so `inverseMass = 0` represents an immovable particle.
+ * Vector fields are `readonly` references: change them in place, e.g.
+ * `particle.position.set(0, 1, 0)`.
+ */
+export declare class Particle {
+    /** Position in meters. */
+    readonly position: Vec3;
+    /** Velocity in meters per second. */
+    readonly velocity: Vec3;
+    /** Constant acceleration in m/s², independent of mass. Typically gravity. */
+    readonly acceleration: Vec3;
+    /** Sum of forces in newtons applied since the last `integrate`. */
+    readonly forceAccum: Vec3;
+    /** Fraction of velocity kept per second, in [0, 1]. `1` disables damping. */
+    damping: number;
+    /** Reciprocal of mass in 1/kg. `0` makes the particle immovable. */
+    inverseMass: number;
+    /** Mass in kilograms. `Infinity` when `inverseMass` is `0`. */
+    get mass(): number;
+    /**
+     * Sets the mass.
+     *
+     * @param mass Mass in kilograms. `Infinity` makes the particle immovable.
+     * @throws RangeError If `mass` is not positive.
+     */
+    setMass(mass: number): void;
+    /** Whether forces and integration can move this particle. */
+    hasFiniteMass(): boolean;
+    /**
+     * Adds a force for the next `integrate`.
+     *
+     * @param force Force in newtons.
+     */
+    addForce(force: Vec3Like): void;
+    /** Discards all accumulated forces. */
+    clearAccumulator(): void;
+    /**
+     * Advances the particle by one step and clears the force accumulator.
+     *
+     * Velocity is updated first and the new velocity moves the position. A particle with
+     * `inverseMass = 0` does not move, whatever its velocity.
+     *
+     * @param dt Step length in seconds.
+     * @throws RangeError If `dt` is not positive.
+     */
+    integrate(dt: number): void;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export { FixedStepLoop, Particle, ParticleWorld } from './engine/index.js';
+export type { FrameResult } from './engine/index.js';
+export { EPSILON, approxEqual, clamp, Vec3, Mat3x3, Mat3x4, Quaternion } from './math/index.js';
+export type { QuatLike, Vec3Like } from './math/index.js';