@holoscript/engine 6.0.3 → 6.0.4

package/dist/chunk-BL7IDTHE.js

@@ -0,0 +1,218 @@
+// src/simulation/AutoMesher.ts
+function meshBox(options) {
+  const origin = options.origin ?? [0, 0, 0];
+  const [lx, ly, lz] = options.size;
+  const [nx, ny, nz] = options.divisions ?? [4, 4, 4];
+  if (nx < 1 || ny < 1 || nz < 1) {
+    throw new Error(`Divisions must be >= 1, got [${nx}, ${ny}, ${nz}]`);
+  }
+  if (lx <= 0 || ly <= 0 || lz <= 0) {
+    throw new Error(`Size must be positive, got [${lx}, ${ly}, ${lz}]`);
+  }
+  const nodeCount = (nx + 1) * (ny + 1) * (nz + 1);
+  const vertices = new Float64Array(nodeCount * 3);
+  let idx = 0;
+  for (let k = 0; k <= nz; k++) {
+    for (let j = 0; j <= ny; j++) {
+      for (let i = 0; i <= nx; i++) {
+        vertices[idx++] = origin[0] + i * lx / nx;
+        vertices[idx++] = origin[1] + j * ly / ny;
+        vertices[idx++] = origin[2] + k * lz / nz;
+      }
+    }
+  }
+  function nodeIndex(i, j, k) {
+    return k * (nx + 1) * (ny + 1) + j * (nx + 1) + i;
+  }
+  const elementCount = nx * ny * nz * 5;
+  const tetrahedra = new Uint32Array(elementCount * 4);
+  let tetIdx = 0;
+  for (let k = 0; k < nz; k++) {
+    for (let j = 0; j < ny; j++) {
+      for (let i = 0; i < nx; i++) {
+        const v0 = nodeIndex(i, j, k);
+        const v1 = nodeIndex(i + 1, j, k);
+        const v2 = nodeIndex(i + 1, j + 1, k);
+        const v3 = nodeIndex(i, j + 1, k);
+        const v4 = nodeIndex(i, j, k + 1);
+        const v5 = nodeIndex(i + 1, j, k + 1);
+        const v6 = nodeIndex(i + 1, j + 1, k + 1);
+        const v7 = nodeIndex(i, j + 1, k + 1);
+        if ((i + j + k) % 2 === 0) {
+          tetrahedra[tetIdx++] = v0;
+          tetrahedra[tetIdx++] = v1;
+          tetrahedra[tetIdx++] = v3;
+          tetrahedra[tetIdx++] = v4;
+          tetrahedra[tetIdx++] = v1;
+          tetrahedra[tetIdx++] = v2;
+          tetrahedra[tetIdx++] = v3;
+          tetrahedra[tetIdx++] = v6;
+          tetrahedra[tetIdx++] = v4;
+          tetrahedra[tetIdx++] = v5;
+          tetrahedra[tetIdx++] = v1;
+          tetrahedra[tetIdx++] = v6;
+          tetrahedra[tetIdx++] = v4;
+          tetrahedra[tetIdx++] = v7;
+          tetrahedra[tetIdx++] = v6;
+          tetrahedra[tetIdx++] = v3;
+          tetrahedra[tetIdx++] = v1;
+          tetrahedra[tetIdx++] = v4;
+          tetrahedra[tetIdx++] = v6;
+          tetrahedra[tetIdx++] = v3;
+        } else {
+          tetrahedra[tetIdx++] = v1;
+          tetrahedra[tetIdx++] = v0;
+          tetrahedra[tetIdx++] = v5;
+          tetrahedra[tetIdx++] = v2;
+          tetrahedra[tetIdx++] = v3;
+          tetrahedra[tetIdx++] = v0;
+          tetrahedra[tetIdx++] = v2;
+          tetrahedra[tetIdx++] = v7;
+          tetrahedra[tetIdx++] = v4;
+          tetrahedra[tetIdx++] = v5;
+          tetrahedra[tetIdx++] = v0;
+          tetrahedra[tetIdx++] = v7;
+          tetrahedra[tetIdx++] = v6;
+          tetrahedra[tetIdx++] = v5;
+          tetrahedra[tetIdx++] = v7;
+          tetrahedra[tetIdx++] = v2;
+          tetrahedra[tetIdx++] = v0;
+          tetrahedra[tetIdx++] = v5;
+          tetrahedra[tetIdx++] = v2;
+          tetrahedra[tetIdx++] = v7;
+        }
+      }
+    }
+  }
+  return { vertices, tetrahedra, nodeCount, elementCount };
+}
+function findNodesOnFace(mesh, face, tolerance = 1e-10) {
+  const verts = mesh.vertices;
+  const nodeCount = mesh.nodeCount;
+  let minX = Infinity, maxX = -Infinity;
+  let minY = Infinity, maxY = -Infinity;
+  let minZ = Infinity, maxZ = -Infinity;
+  for (let i = 0; i < nodeCount; i++) {
+    const x = verts[i * 3], y = verts[i * 3 + 1], z = verts[i * 3 + 2];
+    if (x < minX) minX = x;
+    if (x > maxX) maxX = x;
+    if (y < minY) minY = y;
+    if (y > maxY) maxY = y;
+    if (z < minZ) minZ = z;
+    if (z > maxZ) maxZ = z;
+  }
+  const targets = {
+    "x-": { axis: 0, value: minX },
+    "x+": { axis: 0, value: maxX },
+    "y-": { axis: 1, value: minY },
+    "y+": { axis: 1, value: maxY },
+    "z-": { axis: 2, value: minZ },
+    "z+": { axis: 2, value: maxZ }
+  };
+  const { axis, value } = targets[face];
+  const nodes = [];
+  for (let i = 0; i < nodeCount; i++) {
+    if (Math.abs(verts[i * 3 + axis] - value) < tolerance) {
+      nodes.push(i);
+    }
+  }
+  return nodes;
+}
+function findNodesInSphere(mesh, center, radius) {
+  const verts = mesh.vertices;
+  const r2 = radius * radius;
+  const nodes = [];
+  for (let i = 0; i < mesh.nodeCount; i++) {
+    const dx = verts[i * 3] - center[0];
+    const dy = verts[i * 3 + 1] - center[1];
+    const dz = verts[i * 3 + 2] - center[2];
+    if (dx * dx + dy * dy + dz * dz <= r2) {
+      nodes.push(i);
+    }
+  }
+  return nodes;
+}
+var registeredMesher = null;
+function registerWasmMesher(mesher) {
+  registeredMesher = mesher;
+}
+async function meshSurface(surface, options) {
+  if (registeredMesher) {
+    return registeredMesher.tetrahedralize(surface, options);
+  }
+  const verts = surface.vertices;
+  const nodeCount = verts.length / 3;
+  let minX = Infinity, maxX = -Infinity;
+  let minY = Infinity, maxY = -Infinity;
+  let minZ = Infinity, maxZ = -Infinity;
+  for (let i = 0; i < nodeCount; i++) {
+    const x = verts[i * 3], y = verts[i * 3 + 1], z = verts[i * 3 + 2];
+    if (x < minX) minX = x;
+    if (x > maxX) maxX = x;
+    if (y < minY) minY = y;
+    if (y > maxY) maxY = y;
+    if (z < minZ) minZ = z;
+    if (z > maxZ) maxZ = z;
+  }
+  const lx = maxX - minX || 1;
+  const ly = maxY - minY || 1;
+  const lz = maxZ - minZ || 1;
+  const targetEdge = options?.maxEdgeLength ?? Math.min(lx, ly, lz) / 4;
+  const nx = Math.max(2, Math.round(lx / targetEdge));
+  const ny = Math.max(2, Math.round(ly / targetEdge));
+  const nz = Math.max(2, Math.round(lz / targetEdge));
+  return meshBox({
+    origin: [minX, minY, minZ],
+    size: [lx, ly, lz],
+    divisions: [nx, ny, nz]
+  });
+}
+function meshQuality(mesh) {
+  const verts = mesh.vertices;
+  const tets = mesh.tetrahedra;
+  let minVol = Infinity, maxVol = -Infinity, sumVol = 0;
+  let minAR = Infinity;
+  let inverted = 0;
+  for (let e = 0; e < mesh.elementCount; e++) {
+    const base = e * 4;
+    const n0 = tets[base], n1 = tets[base + 1], n2 = tets[base + 2], n3 = tets[base + 3];
+    const dx1 = verts[n1 * 3] - verts[n0 * 3], dy1 = verts[n1 * 3 + 1] - verts[n0 * 3 + 1], dz1 = verts[n1 * 3 + 2] - verts[n0 * 3 + 2];
+    const dx2 = verts[n2 * 3] - verts[n0 * 3], dy2 = verts[n2 * 3 + 1] - verts[n0 * 3 + 1], dz2 = verts[n2 * 3 + 2] - verts[n0 * 3 + 2];
+    const dx3 = verts[n3 * 3] - verts[n0 * 3], dy3 = verts[n3 * 3 + 1] - verts[n0 * 3 + 1], dz3 = verts[n3 * 3 + 2] - verts[n0 * 3 + 2];
+    const det = dx1 * (dy2 * dz3 - dz2 * dy3) - dy1 * (dx2 * dz3 - dz2 * dx3) + dz1 * (dx2 * dy3 - dy2 * dx3);
+    const vol = det / 6;
+    if (vol < 0) inverted++;
+    const absVol = Math.abs(vol);
+    if (absVol < minVol) minVol = absVol;
+    if (absVol > maxVol) maxVol = absVol;
+    sumVol += absVol;
+    const edges = [
+      Math.sqrt(dx1 * dx1 + dy1 * dy1 + dz1 * dz1),
+      Math.sqrt(dx2 * dx2 + dy2 * dy2 + dz2 * dz2),
+      Math.sqrt(dx3 * dx3 + dy3 * dy3 + dz3 * dz3),
+      Math.sqrt((dx2 - dx1) ** 2 + (dy2 - dy1) ** 2 + (dz2 - dz1) ** 2),
+      Math.sqrt((dx3 - dx1) ** 2 + (dy3 - dy1) ** 2 + (dz3 - dz1) ** 2),
+      Math.sqrt((dx3 - dx2) ** 2 + (dy3 - dy2) ** 2 + (dz3 - dz2) ** 2)
+    ];
+    const minE = Math.min(...edges);
+    const maxE = Math.max(...edges);
+    const ar = minE > 0 ? minE / maxE : 0;
+    if (ar < minAR) minAR = ar;
+  }
+  return {
+    minVolume: minVol === Infinity ? 0 : minVol,
+    maxVolume: maxVol === -Infinity ? 0 : maxVol,
+    avgVolume: mesh.elementCount > 0 ? sumVol / mesh.elementCount : 0,
+    minAspectRatio: minAR === Infinity ? 0 : minAR,
+    invertedCount: inverted
+  };
+}
+
+export {
+  meshBox,
+  findNodesOnFace,
+  findNodesInSphere,
+  registerWasmMesher,
+  meshSurface,
+  meshQuality
+};