aether-physics 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Brandon Berisford
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,79 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# Aether
+
+A 3D rigid-body physics engine written from scratch in TypeScript, with a browser playground built on Lit and Three.js.
+
+This is a learning project. The engine is built in phases, from vectors to stacking boxes to ragdolls, following Ian Millington's *Game Physics Engine Development*, Erin Catto's solver talks, and the resources collected at [brm.io/game-physics-for-beginners](https://brm.io/game-physics-for-beginners/).
+
+- **[docs/PLAN.md](docs/PLAN.md):** the phased build plan, with goals, checklists, tests and demos for each phase
+- **[docs/RESOURCES.md](docs/RESOURCES.md):** books, articles, talks and reference engines for each phase
+- **[docs/DEMOS.md](docs/DEMOS.md):** how to build a demo: templates, using the engine from Three.js, demo controls and UI style
+
+**[Try the playground](https://beyondbelief96.github.io/aether/)**. Each push to `main` deploys it to GitHub Pages.
+
+## Using the package
+
+```sh
+npm install aether-physics
+```
+
+```ts
+import { Quaternion, Vec3 } from 'aether-physics';
+
+const q = new Quaternion().setFromAxisAngle({ x: 0, y: 1, z: 0 }, Math.PI / 2);
+q.rotateVec3({ x: 1, y: 0, z: 0 }, new Vec3()); // about (0, 0, -1)
+```
+
+It's early: so far the package has the math library and a fixed-timestep loop. Physics arrives with the later phases below, and the API can change in any 0.x release.
+
+## Running it
+
+```sh
+npm install
+npm run dev        # playground at http://localhost:5173
+npm test           # Vitest in watch mode
+npm run test:run   # Vitest once
+npm run typecheck  # tsc, no emit
+npm run build      # typecheck, then production build of the playground to dist-playground/
+npm run build:lib  # build the npm package to dist/
+```
+
+Keyboard: **Space** pauses, **.** steps once while paused, **R** resets the demo.
+
+## Layout
+
+```
+src/
+  math/         Vec3, Mat3, Mat4, Quat                     Phase 1
+  engine/       game loop, Particle, RigidBody, World      Phases 0, 2, 4, 7
+  forces/       force generators                           Phases 3, 4
+  collision/    shapes, broadphase, narrowphase            Phase 5
+  constraints/  contact solver, joints                     Phases 6, 7
+  playground/   the app in the browser, which uses the engine only through "aether-physics"
+    demos/      one file per demo (the only engine + Three.js code)
+    ui/         Lit components
+```
+
+## Rules
+
+- The engine (`math`, `engine`, `forces`, `collision`, `constraints`) never imports `three` or touches the DOM. Demos are the bridge.
+- Physics runs on a fixed timestep; rendering interpolates between steps.
+- TypeScript runs with `erasableSyntaxOnly`: no `enum`, `namespace` or parameter properties.
+- Lit components use `static properties` with `declare` fields and `customElements.define`, never decorators.
+
+## Progress
+
+| Phase | Topic | Status |
+|---|---|---|
+| 0 | Scaffold and game loop | ✅ |
+| 1 | Math library | ✅ |
+| 2 | Particles and integration | |
+| 3 | Forces, springs and mass aggregates | |
+| 4 | Rigid bodies | |
+| 5 | Collision detection | |
+| 6 | Collision response and friction | |
+| 7 | Joints, sleeping and stability | |
+| 8 | Stretch goals | |
+
+## License
+
+[MIT](LICENSE)

package/dist/index.js

@@ -0,0 +1,56 @@
+import { a as e, i as t, n, o as r, r as i, s as a, t as o } from "./math-DrI-pge3.js";
+//#region src/engine/loop.ts
+var s = .25, c = class {
+	timeScale = 1;
+	paused = !1;
+	maxStepsPerFrame = 8;
+	#e;
+	#t = 0;
+	#n = null;
+	#r = 0;
+	#i = 0;
+	constructor(e = 60) {
+		this.#e = 1 / e;
+	}
+	get dt() {
+		return this.#e;
+	}
+	get hz() {
+		return 1 / this.#e;
+	}
+	set hz(e) {
+		if (!(e > 0)) throw RangeError(`hz must be positive, got ${e}`);
+		this.#e = 1 / e;
+	}
+	get simTime() {
+		return this.#r;
+	}
+	stepOnce() {
+		this.#i++;
+	}
+	reset() {
+		this.#t = 0, this.#n = null, this.#r = 0, this.#i = 0;
+	}
+	advance(e, t) {
+		let n = this.#n;
+		this.#n = e;
+		let r = n === null ? 0 : Math.min((e - n) / 1e3, s), i = 0, a = () => {
+			t(this.#e), this.#r += this.#e, i++;
+		};
+		for (; this.#i > 0; this.#i--) a();
+		if (this.paused) return {
+			steps: i,
+			alpha: 1,
+			droppedTime: !1
+		};
+		for (this.#t += r * this.timeScale; this.#t >= this.#e && i < this.maxStepsPerFrame;) a(), this.#t -= this.#e;
+		let o = !1;
+		return this.#t >= this.#e && (this.#t %= this.#e, o = !0), {
+			steps: i,
+			alpha: this.#t / this.#e,
+			droppedTime: o
+		};
+	}
+};
+//#endregion
+export { e as EPSILON, c as FixedStepLoop, i as Mat3x3, n as Mat3x4, o as Quaternion, t as Vec3, r as approxEqual, a as clamp };

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";