@es3d/es3d 1.0.0 → 1.0.1

package/src/math/random.js

@@ -1,30 +1,30 @@
-// Deterministic pseudo random numbers.
-//
-// ES3D procedural elements (<scatter>) must produce the same result in every
-// implementation, so the generator is part of the format specification:
-// mulberry32 seeded with the 32-bit unsigned integer `seed`, returning floats in
-// [0, 1) as (state >>> 0) / 2^32 exactly as implemented below.
-
-export function mulberry32(seed) {
-  let a = seed >>> 0;
-  return function next() {
-    a = (a + 0x6d2b79f5) >>> 0;
-    let t = a;
-    t = Math.imul(t ^ (t >>> 15), t | 1);
-    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
-    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
-  };
-}
-
-/** Uniform value in [lo, hi] for a range [lo, hi]. */
-export function inRange(rand, range) {
-  return range[0] + (range[1] - range[0]) * rand();
-}
-
-/** Integer hash -> [0,1) (used for value noise in procedural textures). */
-export function hash2(x, y, seed) {
-  let h = Math.imul(x | 0, 0x27d4eb2d) ^ Math.imul(y | 0, 0x165667b1) ^ Math.imul(seed | 0, 0x9e3779b9);
-  h = Math.imul(h ^ (h >>> 15), 0x85ebca6b);
-  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);
-  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;
-}
+// Deterministic pseudo random numbers.
+//
+// ES3D procedural elements (<scatter>) must produce the same result in every
+// implementation, so the generator is part of the format specification:
+// mulberry32 seeded with the 32-bit unsigned integer `seed`, returning floats in
+// [0, 1) as (state >>> 0) / 2^32 exactly as implemented below.
+
+export function mulberry32(seed) {
+  let a = seed >>> 0;
+  return function next() {
+    a = (a + 0x6d2b79f5) >>> 0;
+    let t = a;
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+/** Uniform value in [lo, hi] for a range [lo, hi]. */
+export function inRange(rand, range) {
+  return range[0] + (range[1] - range[0]) * rand();
+}
+
+/** Integer hash -> [0,1) (used for value noise in procedural textures). */
+export function hash2(x, y, seed) {
+  let h = Math.imul(x | 0, 0x27d4eb2d) ^ Math.imul(y | 0, 0x165667b1) ^ Math.imul(seed | 0, 0x9e3779b9);
+  h = Math.imul(h ^ (h >>> 15), 0x85ebca6b);
+  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);
+  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;
+}

package/src/math/trig.js

@@ -1,65 +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);
-}
+// 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

@@ -1,81 +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;
-}
+// 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;
+}