@es3d/es3d 0.0.0-stage → 1.0.1

package/src/math/trig.js

@@ -0,0 +1,65 @@
+// Normative sine and cosine for placement.
+//
+// IEEE 754 does not require Math.sin and Math.cos to be correctly rounded, so
+// two readers can disagree in the last bit. Scatter positions and rotation
+// matrices use the functions below instead. Every operation is a binary64
+// round-to-nearest add, subtract or multiply, in the order written, so every
+// IEEE 754 implementation produces the same bits.
+//
+// Tessellation of spheres, gears and paths may keep the platform sin and cos.
+// Those meshes are bounded by a chordal error, not hashed.
+
+const PI = Math.PI;
+const TWO_PI = PI * 2;
+const HALF_PI = PI * 0.5;
+const QUARTER_PI = PI * 0.25;
+
+// fdlibm __kernel_sin coefficients, as binary64 literals. Valid for |x| <= π/4.
+const S1 = -1.66666666666666324348e-1;
+const S2 = 8.33333333332248946124e-3;
+const S3 = -1.98412698298579493134e-4;
+const S4 = 2.75573137070700676789e-6;
+const S5 = -2.50507602534068634195e-8;
+const S6 = 1.58969099521155010221e-10;
+
+// fdlibm __kernel_cos coefficients.
+const C1 = 4.16666666666666019037e-2;
+const C2 = -1.38888888888741095749e-3;
+const C3 = 2.48015872894767294178e-5;
+const C4 = -2.75573143513906633035e-7;
+const C5 = 2.0875723212981748279e-9;
+const C6 = -1.13596475577881948265e-11;
+
+function kernelSin(x) {
+  const z = x * x;
+  const v = z * x;
+  const r = S2 + z * (S3 + z * (S4 + z * (S5 + z * S6)));
+  return x + v * (S1 + z * r);
+}
+
+function kernelCos(x) {
+  const z = x * x;
+  const r = z * (C1 + z * (C2 + z * (C3 + z * (C4 + z * (C5 + z * C6)))));
+  // 1 - z/2 + z^2 * (C1 + ...). The extra z is the Taylor power; r already holds one.
+  return 1 - 0.5 * z + z * r;
+}
+
+/** Sine of a radian angle. Finite inputs only; non-finite values pass through. */
+export function es3dSin(x) {
+  if (!Number.isFinite(x)) return x;
+  let y = x - TWO_PI * Math.round(x / TWO_PI);
+  let sign = 1;
+  if (y < 0) {
+    sign = -1;
+    y = -y;
+  }
+  if (y > HALF_PI) y = PI - y;
+  if (y < 0) y = 0;
+  const s = y > QUARTER_PI ? kernelCos(HALF_PI - y) : kernelSin(y);
+  return sign < 0 ? -s : s;
+}
+
+/** Cosine. Defined as sin(x + π/2) with the same reduction. */
+export function es3dCos(x) {
+  return es3dSin(x + HALF_PI);
+}

package/src/math/vec3.js

@@ -0,0 +1,81 @@
+// Small vector helpers operating on plain arrays [x, y, z].
+
+export const add = (a, b) => [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+export const sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+export const scale = (a, s) => [a[0] * s, a[1] * s, a[2] * s];
+export const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+export const cross = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+export const length = (a) => Math.hypot(a[0], a[1], a[2]);
+export const distance = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
+export const lerp = (a, b, t) => [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, a[2] + (b[2] - a[2]) * t];
+
+export function normalize(a) {
+  const l = Math.hypot(a[0], a[1], a[2]);
+  return l > 1e-20 ? [a[0] / l, a[1] / l, a[2] / l] : [0, 0, 0];
+}
+
+/** Any unit vector perpendicular to a (unit) vector. */
+export function perpendicular(a) {
+  const ax = Math.abs(a[0]), ay = Math.abs(a[1]), az = Math.abs(a[2]);
+  const other = ax <= ay && ax <= az ? [1, 0, 0] : ay <= az ? [0, 1, 0] : [0, 0, 1];
+  return normalize(cross(a, other));
+}
+
+/** Rotate v around unit axis k by angle (Rodrigues). */
+export function rotateAround(v, k, angle) {
+  const c = Math.cos(angle), s = Math.sin(angle);
+  const kv = cross(k, v);
+  const kd = dot(k, v) * (1 - c);
+  return [v[0] * c + kv[0] * s + k[0] * kd, v[1] * c + kv[1] * s + k[1] * kd, v[2] * c + kv[2] * s + k[2] * kd];
+}
+
+/** Axis-aligned bounding box helpers: {min:[3], max:[3]} */
+export function emptyBounds() {
+  return { min: [Infinity, Infinity, Infinity], max: [-Infinity, -Infinity, -Infinity] };
+}
+
+export function boundsIsEmpty(b) {
+  return !(b.min[0] <= b.max[0]);
+}
+
+export function expandBounds(b, x, y, z) {
+  if (x < b.min[0]) b.min[0] = x;
+  if (y < b.min[1]) b.min[1] = y;
+  if (z < b.min[2]) b.min[2] = z;
+  if (x > b.max[0]) b.max[0] = x;
+  if (y > b.max[1]) b.max[1] = y;
+  if (z > b.max[2]) b.max[2] = z;
+  return b;
+}
+
+export function unionBounds(a, b) {
+  expandBounds(a, b.min[0], b.min[1], b.min[2]);
+  expandBounds(a, b.max[0], b.max[1], b.max[2]);
+  return a;
+}
+
+/** Transform an AABB by a matrix (returns the AABB of the transformed box). */
+export function transformBounds(b, m) {
+  const out = emptyBounds();
+  if (boundsIsEmpty(b)) return out;
+  for (let i = 0; i < 8; i++) {
+    const x = i & 1 ? b.max[0] : b.min[0];
+    const y = i & 2 ? b.max[1] : b.min[1];
+    const z = i & 4 ? b.max[2] : b.min[2];
+    expandBounds(
+      out,
+      m[0] * x + m[4] * y + m[8] * z + m[12],
+      m[1] * x + m[5] * y + m[9] * z + m[13],
+      m[2] * x + m[6] * y + m[10] * z + m[14],
+    );
+  }
+  return out;
+}
+
+export function boundsCenter(b) {
+  return [(b.min[0] + b.max[0]) / 2, (b.min[1] + b.max[1]) / 2, (b.min[2] + b.max[2]) / 2];
+}
+
+export function boundsRadius(b) {
+  return Math.hypot(b.max[0] - b.min[0], b.max[1] - b.min[1], b.max[2] - b.min[2]) / 2;
+}