@es3d/es3d 1.0.0 → 1.0.1

package/src/cache/mesh-bundle.js

@@ -1,123 +1,123 @@
-// Mesh bundle: the binary record the persistent geometry cache stores, one
-// per document. ES3D's own layout, little-endian:
-//
-//   0   "ES3G"                         magic
-//   4   u32 layout version (1)
-//   8   u32 byte length of the description
-//   12  description, UTF-8 JSON, padded with spaces to a multiple of 4 bytes
-//   ..  data: per stored level, at the offset its description gives from the
-//       start of the data (a multiple of 4): positions f32[3v], normals
-//       f32[3v], uvs f32[2v], then indices, u16[i] when every index fits in
-//       16 bits (`w` 2) else u32[i] (`w` 4)
-//
-// The description:
-//   { key, entries: [[{ lod, kind, v, i, w, at, reports }, ...], ...] }
-// with one list of levels per cached shape, in the order of the shapes'
-// identities (the record's key covers that order). `reports` lists the
-// diagnostics generation reported, as [severity, code, message].
-//
-// Decoding returns views into the stored buffer (only 16-bit indices are
-// widened, by a native copy) and checks the structure it relies on: magic,
-// layout, lengths, offsets and primitive counts. It does not check that every
-// index names a vertex: only code of the same origin can write the store, and
-// an index out of range cannot reach memory outside the arrays, in
-// JavaScript or on the GPU.
-
-import { Mesh } from '../geometry/mesh.js';
-
-const MAGIC = 0x47335345; // "ES3G" read as a little-endian u32
-export const BUNDLE_VERSION = 1;
-const littleEndian = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
-const encoder = new TextEncoder();
-const decoder = new TextDecoder();
-
-const align4 = (n) => (n + 3) & ~3;
-
-/**
- * @param {string} key
- * @param {{lod: number, mesh: Mesh, reports?: object[]|null}[][]} entries levels per shape
- * @returns {ArrayBuffer}
- */
-export function encodeBundle(key, entries) {
-  // lay the arrays out first, then the description that points at them
-  const plan = [];
-  let dataBytes = 0;
-  const description = { key, entries: [] };
-  for (const list of entries) {
-    const levels = [];
-    for (const { lod, mesh, reports } of list) {
-      const v = mesh.positions.length / 3, i = mesh.indices.length;
-      const w = v <= 0x10000 ? 2 : 4;
-      levels.push({ lod, kind: mesh.kind, v, i, w, at: dataBytes, reports: reports ? reports.map((r) => [r.severity, r.code, r.message]) : [] });
-      plan.push({ mesh, at: dataBytes, w });
-      dataBytes += v * 32 + align4(i * w);
-    }
-    description.entries.push(levels);
-  }
-  const meta = encoder.encode(JSON.stringify(description));
-  const head = 12 + align4(meta.length);
-  const buffer = new ArrayBuffer(head + dataBytes);
-  const u8 = new Uint8Array(buffer);
-  const view = new DataView(buffer);
-  view.setUint32(0, MAGIC, true);
-  view.setUint32(4, BUNDLE_VERSION, true);
-  view.setUint32(8, head - 12, true);
-  u8.set(meta, 12);
-  u8.fill(0x20, 12 + meta.length, head);
-  for (const { mesh, at, w } of plan) {
-    const v = mesh.positions.length / 3;
-    const base = head + at;
-    new Float32Array(buffer, base, v * 3).set(mesh.positions);
-    new Float32Array(buffer, base + v * 12, v * 3).set(mesh.normals);
-    new Float32Array(buffer, base + v * 24, v * 2).set(mesh.uvs);
-    new (w === 2 ? Uint16Array : Uint32Array)(buffer, base + v * 32, mesh.indices.length).set(mesh.indices);
-  }
-  return buffer;
-}
-
-const isCount = (n) => Number.isInteger(n) && n >= 0;
-
-/**
- * @param {ArrayBuffer} buffer
- * @returns {{key: string, entries: {lod: number, mesh: Mesh, reports: object[]}[][]}|null}
- *   null when the buffer is not a valid bundle of this layout
- */
-export function decodeBundle(buffer) {
-  if (!littleEndian || !(buffer instanceof ArrayBuffer) || buffer.byteLength < 12) return null;
-  const view = new DataView(buffer);
-  if (view.getUint32(0, true) !== MAGIC || view.getUint32(4, true) !== BUNDLE_VERSION) return null;
-  const metaBytes = view.getUint32(8, true);
-  if (metaBytes % 4 || 12 + metaBytes > buffer.byteLength) return null;
-  let description;
-  try {
-    description = JSON.parse(decoder.decode(new Uint8Array(buffer, 12, metaBytes)));
-  } catch {
-    return null;
-  }
-  if (!description || typeof description.key !== 'string' || !Array.isArray(description.entries)) return null;
-  const data = 12 + metaBytes;
-  const entries = [];
-  for (const list of description.entries) {
-    if (!Array.isArray(list)) return null;
-    const levels = [];
-    for (const l of list) {
-      if (!l || !isCount(l.lod) || !isCount(l.v) || !isCount(l.i) || !isCount(l.at) || l.at % 4) return null;
-      if ((l.kind !== 'triangles' && l.kind !== 'lines') || (l.w !== 2 && l.w !== 4) || (l.w === 2 && l.v > 0x10000)) return null;
-      if (l.i % (l.kind === 'lines' ? 2 : 3)) return null;
-      const at = data + l.at;
-      if (at + l.v * 32 + l.i * l.w > buffer.byteLength) return null;
-      const indices = l.w === 2 ? new Uint32Array(new Uint16Array(buffer, at + l.v * 32, l.i)) : new Uint32Array(buffer, at + l.v * 32, l.i);
-      const mesh = new Mesh({
-        positions: new Float32Array(buffer, at, l.v * 3),
-        normals: new Float32Array(buffer, at + l.v * 12, l.v * 3),
-        uvs: new Float32Array(buffer, at + l.v * 24, l.v * 2),
-        indices,
-        kind: l.kind,
-      });
-      const reports = Array.isArray(l.reports) ? l.reports.filter((r) => Array.isArray(r) && r.length === 3).map(([severity, code, message]) => ({ severity: String(severity), code: String(code), message: String(message) })) : [];
-      levels.push({ lod: l.lod, mesh, reports });
-    }
-    entries.push(levels);
-  }
-  return { key: description.key, entries };
-}
+// Mesh bundle: the binary record the persistent geometry cache stores, one
+// per document. ES3D's own layout, little-endian:
+//
+//   0   "ES3G"                         magic
+//   4   u32 layout version (1)
+//   8   u32 byte length of the description
+//   12  description, UTF-8 JSON, padded with spaces to a multiple of 4 bytes
+//   ..  data: per stored level, at the offset its description gives from the
+//       start of the data (a multiple of 4): positions f32[3v], normals
+//       f32[3v], uvs f32[2v], then indices, u16[i] when every index fits in
+//       16 bits (`w` 2) else u32[i] (`w` 4)
+//
+// The description:
+//   { key, entries: [[{ lod, kind, v, i, w, at, reports }, ...], ...] }
+// with one list of levels per cached shape, in the order of the shapes'
+// identities (the record's key covers that order). `reports` lists the
+// diagnostics generation reported, as [severity, code, message].
+//
+// Decoding returns views into the stored buffer (only 16-bit indices are
+// widened, by a native copy) and checks the structure it relies on: magic,
+// layout, lengths, offsets and primitive counts. It does not check that every
+// index names a vertex: only code of the same origin can write the store, and
+// an index out of range cannot reach memory outside the arrays, in
+// JavaScript or on the GPU.
+
+import { Mesh } from '../geometry/mesh.js';
+
+const MAGIC = 0x47335345; // "ES3G" read as a little-endian u32
+export const BUNDLE_VERSION = 1;
+const littleEndian = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+
+const align4 = (n) => (n + 3) & ~3;
+
+/**
+ * @param {string} key
+ * @param {{lod: number, mesh: Mesh, reports?: object[]|null}[][]} entries levels per shape
+ * @returns {ArrayBuffer}
+ */
+export function encodeBundle(key, entries) {
+  // lay the arrays out first, then the description that points at them
+  const plan = [];
+  let dataBytes = 0;
+  const description = { key, entries: [] };
+  for (const list of entries) {
+    const levels = [];
+    for (const { lod, mesh, reports } of list) {
+      const v = mesh.positions.length / 3, i = mesh.indices.length;
+      const w = v <= 0x10000 ? 2 : 4;
+      levels.push({ lod, kind: mesh.kind, v, i, w, at: dataBytes, reports: reports ? reports.map((r) => [r.severity, r.code, r.message]) : [] });
+      plan.push({ mesh, at: dataBytes, w });
+      dataBytes += v * 32 + align4(i * w);
+    }
+    description.entries.push(levels);
+  }
+  const meta = encoder.encode(JSON.stringify(description));
+  const head = 12 + align4(meta.length);
+  const buffer = new ArrayBuffer(head + dataBytes);
+  const u8 = new Uint8Array(buffer);
+  const view = new DataView(buffer);
+  view.setUint32(0, MAGIC, true);
+  view.setUint32(4, BUNDLE_VERSION, true);
+  view.setUint32(8, head - 12, true);
+  u8.set(meta, 12);
+  u8.fill(0x20, 12 + meta.length, head);
+  for (const { mesh, at, w } of plan) {
+    const v = mesh.positions.length / 3;
+    const base = head + at;
+    new Float32Array(buffer, base, v * 3).set(mesh.positions);
+    new Float32Array(buffer, base + v * 12, v * 3).set(mesh.normals);
+    new Float32Array(buffer, base + v * 24, v * 2).set(mesh.uvs);
+    new (w === 2 ? Uint16Array : Uint32Array)(buffer, base + v * 32, mesh.indices.length).set(mesh.indices);
+  }
+  return buffer;
+}
+
+const isCount = (n) => Number.isInteger(n) && n >= 0;
+
+/**
+ * @param {ArrayBuffer} buffer
+ * @returns {{key: string, entries: {lod: number, mesh: Mesh, reports: object[]}[][]}|null}
+ *   null when the buffer is not a valid bundle of this layout
+ */
+export function decodeBundle(buffer) {
+  if (!littleEndian || !(buffer instanceof ArrayBuffer) || buffer.byteLength < 12) return null;
+  const view = new DataView(buffer);
+  if (view.getUint32(0, true) !== MAGIC || view.getUint32(4, true) !== BUNDLE_VERSION) return null;
+  const metaBytes = view.getUint32(8, true);
+  if (metaBytes % 4 || 12 + metaBytes > buffer.byteLength) return null;
+  let description;
+  try {
+    description = JSON.parse(decoder.decode(new Uint8Array(buffer, 12, metaBytes)));
+  } catch {
+    return null;
+  }
+  if (!description || typeof description.key !== 'string' || !Array.isArray(description.entries)) return null;
+  const data = 12 + metaBytes;
+  const entries = [];
+  for (const list of description.entries) {
+    if (!Array.isArray(list)) return null;
+    const levels = [];
+    for (const l of list) {
+      if (!l || !isCount(l.lod) || !isCount(l.v) || !isCount(l.i) || !isCount(l.at) || l.at % 4) return null;
+      if ((l.kind !== 'triangles' && l.kind !== 'lines') || (l.w !== 2 && l.w !== 4) || (l.w === 2 && l.v > 0x10000)) return null;
+      if (l.i % (l.kind === 'lines' ? 2 : 3)) return null;
+      const at = data + l.at;
+      if (at + l.v * 32 + l.i * l.w > buffer.byteLength) return null;
+      const indices = l.w === 2 ? new Uint32Array(new Uint16Array(buffer, at + l.v * 32, l.i)) : new Uint32Array(buffer, at + l.v * 32, l.i);
+      const mesh = new Mesh({
+        positions: new Float32Array(buffer, at, l.v * 3),
+        normals: new Float32Array(buffer, at + l.v * 12, l.v * 3),
+        uvs: new Float32Array(buffer, at + l.v * 24, l.v * 2),
+        indices,
+        kind: l.kind,
+      });
+      const reports = Array.isArray(l.reports) ? l.reports.filter((r) => Array.isArray(r) && r.length === 3).map(([severity, code, message]) => ({ severity: String(severity), code: String(code), message: String(message) })) : [];
+      levels.push({ lod: l.lod, mesh, reports });
+    }
+    entries.push(levels);
+  }
+  return { key: description.key, entries };
+}

package/src/cache/sha256.js

@@ -1,73 +1,73 @@
-// SHA-256 (FIPS 180-4), synchronous.
-//
-// The persistent geometry cache names its records by content. Web Crypto's
-// digest() would do, but it is asynchronous and only exists in secure
-// contexts (https, localhost): a page served over plain http on a local
-// network, as the LAN benchmark is, has no crypto.subtle. The inputs hashed
-// here are short (shape parameters and path data), so a plain
-// implementation is fast enough and gives the same digest everywhere.
-
-const K = new Uint32Array([
-  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
-  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
-  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
-  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
-  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
-  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
-  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
-  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
-]);
-
-const W = new Uint32Array(64);
-const encoder = new TextEncoder();
-
-/** SHA-256 of a string (UTF-8) or of bytes, as 64 lowercase hex digits. */
-export function sha256(input) {
-  const data = typeof input === 'string' ? encoder.encode(input) : input instanceof Uint8Array ? input : new Uint8Array(input.buffer || input, input.byteOffset || 0, input.byteLength);
-  // padding: 0x80, zeros, then the bit length as a 64-bit big-endian number
-  const n = data.length;
-  const total = (n + 9 + 63) & ~63;
-  const m = new Uint8Array(total);
-  m.set(data);
-  m[n] = 0x80;
-  const view = new DataView(m.buffer);
-  view.setUint32(total - 8, Math.floor(n / 0x20000000), false);
-  view.setUint32(total - 4, (n << 3) >>> 0, false);
-  let h0 = 0x6a09e667, h1 = 0xbb67ae85, h2 = 0x3c6ef372, h3 = 0xa54ff53a;
-  let h4 = 0x510e527f, h5 = 0x9b05688c, h6 = 0x1f83d9ab, h7 = 0x5be0cd19;
-  for (let off = 0; off < total; off += 64) {
-    for (let i = 0; i < 16; i++) W[i] = view.getUint32(off + i * 4, false);
-    for (let i = 16; i < 64; i++) {
-      const a = W[i - 15], b = W[i - 2];
-      const s0 = ((a >>> 7) | (a << 25)) ^ ((a >>> 18) | (a << 14)) ^ (a >>> 3);
-      const s1 = ((b >>> 17) | (b << 15)) ^ ((b >>> 19) | (b << 13)) ^ (b >>> 10);
-      W[i] = (W[i - 16] + s0 + W[i - 7] + s1) | 0;
-    }
-    let a = h0, b = h1, c = h2, d = h3, e = h4, f = h5, g = h6, h = h7;
-    for (let i = 0; i < 64; i++) {
-      const S1 = ((e >>> 6) | (e << 26)) ^ ((e >>> 11) | (e << 21)) ^ ((e >>> 25) | (e << 7));
-      const t1 = (h + S1 + ((e & f) ^ (~e & g)) + K[i] + W[i]) | 0;
-      const S0 = ((a >>> 2) | (a << 30)) ^ ((a >>> 13) | (a << 19)) ^ ((a >>> 22) | (a << 10));
-      const t2 = (S0 + ((a & b) ^ (a & c) ^ (b & c))) | 0;
-      h = g;
-      g = f;
-      f = e;
-      e = (d + t1) | 0;
-      d = c;
-      c = b;
-      b = a;
-      a = (t1 + t2) | 0;
-    }
-    h0 = (h0 + a) | 0;
-    h1 = (h1 + b) | 0;
-    h2 = (h2 + c) | 0;
-    h3 = (h3 + d) | 0;
-    h4 = (h4 + e) | 0;
-    h5 = (h5 + f) | 0;
-    h6 = (h6 + g) | 0;
-    h7 = (h7 + h) | 0;
-  }
-  let hex = '';
-  for (const v of [h0, h1, h2, h3, h4, h5, h6, h7]) hex += (v >>> 0).toString(16).padStart(8, '0');
-  return hex;
-}
+// SHA-256 (FIPS 180-4), synchronous.
+//
+// The persistent geometry cache names its records by content. Web Crypto's
+// digest() would do, but it is asynchronous and only exists in secure
+// contexts (https, localhost): a page served over plain http on a local
+// network, as the LAN benchmark is, has no crypto.subtle. The inputs hashed
+// here are short (shape parameters and path data), so a plain
+// implementation is fast enough and gives the same digest everywhere.
+
+const K = new Uint32Array([
+  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+
+const W = new Uint32Array(64);
+const encoder = new TextEncoder();
+
+/** SHA-256 of a string (UTF-8) or of bytes, as 64 lowercase hex digits. */
+export function sha256(input) {
+  const data = typeof input === 'string' ? encoder.encode(input) : input instanceof Uint8Array ? input : new Uint8Array(input.buffer || input, input.byteOffset || 0, input.byteLength);
+  // padding: 0x80, zeros, then the bit length as a 64-bit big-endian number
+  const n = data.length;
+  const total = (n + 9 + 63) & ~63;
+  const m = new Uint8Array(total);
+  m.set(data);
+  m[n] = 0x80;
+  const view = new DataView(m.buffer);
+  view.setUint32(total - 8, Math.floor(n / 0x20000000), false);
+  view.setUint32(total - 4, (n << 3) >>> 0, false);
+  let h0 = 0x6a09e667, h1 = 0xbb67ae85, h2 = 0x3c6ef372, h3 = 0xa54ff53a;
+  let h4 = 0x510e527f, h5 = 0x9b05688c, h6 = 0x1f83d9ab, h7 = 0x5be0cd19;
+  for (let off = 0; off < total; off += 64) {
+    for (let i = 0; i < 16; i++) W[i] = view.getUint32(off + i * 4, false);
+    for (let i = 16; i < 64; i++) {
+      const a = W[i - 15], b = W[i - 2];
+      const s0 = ((a >>> 7) | (a << 25)) ^ ((a >>> 18) | (a << 14)) ^ (a >>> 3);
+      const s1 = ((b >>> 17) | (b << 15)) ^ ((b >>> 19) | (b << 13)) ^ (b >>> 10);
+      W[i] = (W[i - 16] + s0 + W[i - 7] + s1) | 0;
+    }
+    let a = h0, b = h1, c = h2, d = h3, e = h4, f = h5, g = h6, h = h7;
+    for (let i = 0; i < 64; i++) {
+      const S1 = ((e >>> 6) | (e << 26)) ^ ((e >>> 11) | (e << 21)) ^ ((e >>> 25) | (e << 7));
+      const t1 = (h + S1 + ((e & f) ^ (~e & g)) + K[i] + W[i]) | 0;
+      const S0 = ((a >>> 2) | (a << 30)) ^ ((a >>> 13) | (a << 19)) ^ ((a >>> 22) | (a << 10));
+      const t2 = (S0 + ((a & b) ^ (a & c) ^ (b & c))) | 0;
+      h = g;
+      g = f;
+      f = e;
+      e = (d + t1) | 0;
+      d = c;
+      c = b;
+      b = a;
+      a = (t1 + t2) | 0;
+    }
+    h0 = (h0 + a) | 0;
+    h1 = (h1 + b) | 0;
+    h2 = (h2 + c) | 0;
+    h3 = (h3 + d) | 0;
+    h4 = (h4 + e) | 0;
+    h5 = (h5 + f) | 0;
+    h6 = (h6 + g) | 0;
+    h7 = (h7 + h) | 0;
+  }
+  let hex = '';
+  for (const v of [h0, h1, h2, h3, h4, h5, h6, h7]) hex += (v >>> 0).toString(16).padStart(8, '0');
+  return hex;
+}