@holoscript/core 7.0.0 → 8.0.1

package/dist/chunk-EKBKLK7P.js

@@ -0,0 +1,1169 @@
+import { vec3SubArray, vec3NormalizeInPlace, vec3CrossArray, vec3ScaleArray } from './chunk-MXFUTKCO.js';
+
+// src/compiler/ProceduralGeometry.ts
+var LOD_PRESETS = {
+  low: {
+    hull: { resolution: 12, boundsPadding: 1.2 },
+    spline: { radialSegments: 8, lengthSteps: 4 },
+    membrane: { subdivisions: 3 }
+  },
+  medium: {
+    hull: { resolution: 24, boundsPadding: 1.3 },
+    spline: { radialSegments: 32, lengthSteps: 12 },
+    membrane: { subdivisions: 8 }
+  },
+  high: {
+    hull: { resolution: 48, boundsPadding: 1.4 },
+    spline: { radialSegments: 64, lengthSteps: 24 },
+    membrane: { subdivisions: 16 }
+  }
+};
+function catmullRom(p0, p1, p2, p3, t) {
+  const t2 = t * t;
+  const t3 = t2 * t;
+  const result = [];
+  for (let i = 0; i < p0.length; i++) {
+    result.push(
+      0.5 * (2 * p1[i] + (-p0[i] + p2[i]) * t + (2 * p0[i] - 5 * p1[i] + 4 * p2[i] - p3[i]) * t2 + (-p0[i] + 3 * p1[i] - 3 * p2[i] + p3[i]) * t3)
+    );
+  }
+  return result;
+}
+function fallbackBox() {
+  const s = 0.5;
+  const positions = new Float32Array([
+    // Front
+    -s,
+    -s,
+    s,
+    s,
+    -s,
+    s,
+    s,
+    s,
+    s,
+    -s,
+    s,
+    s,
+    // Back
+    s,
+    -s,
+    -s,
+    -s,
+    -s,
+    -s,
+    -s,
+    s,
+    -s,
+    s,
+    s,
+    -s,
+    // Top
+    -s,
+    s,
+    s,
+    s,
+    s,
+    s,
+    s,
+    s,
+    -s,
+    -s,
+    s,
+    -s,
+    // Bottom
+    -s,
+    -s,
+    -s,
+    s,
+    -s,
+    -s,
+    s,
+    -s,
+    s,
+    -s,
+    -s,
+    s,
+    // Right
+    s,
+    -s,
+    s,
+    s,
+    -s,
+    -s,
+    s,
+    s,
+    -s,
+    s,
+    s,
+    s,
+    // Left
+    -s,
+    -s,
+    -s,
+    -s,
+    -s,
+    s,
+    -s,
+    s,
+    s,
+    -s,
+    s,
+    -s
+  ]);
+  const normals = new Float32Array([
+    0,
+    0,
+    1,
+    0,
+    0,
+    1,
+    0,
+    0,
+    1,
+    0,
+    0,
+    1,
+    0,
+    0,
+    -1,
+    0,
+    0,
+    -1,
+    0,
+    0,
+    -1,
+    0,
+    0,
+    -1,
+    0,
+    1,
+    0,
+    0,
+    1,
+    0,
+    0,
+    1,
+    0,
+    0,
+    1,
+    0,
+    0,
+    -1,
+    0,
+    0,
+    -1,
+    0,
+    0,
+    -1,
+    0,
+    0,
+    -1,
+    0,
+    1,
+    0,
+    0,
+    1,
+    0,
+    0,
+    1,
+    0,
+    0,
+    1,
+    0,
+    0,
+    -1,
+    0,
+    0,
+    -1,
+    0,
+    0,
+    -1,
+    0,
+    0,
+    -1,
+    0,
+    0
+  ]);
+  const uvs = new Float32Array([
+    0,
+    0,
+    1,
+    0,
+    1,
+    1,
+    0,
+    1,
+    0,
+    0,
+    1,
+    0,
+    1,
+    1,
+    0,
+    1,
+    0,
+    0,
+    1,
+    0,
+    1,
+    1,
+    0,
+    1,
+    0,
+    0,
+    1,
+    0,
+    1,
+    1,
+    0,
+    1,
+    0,
+    0,
+    1,
+    0,
+    1,
+    1,
+    0,
+    1,
+    0,
+    0,
+    1,
+    0,
+    1,
+    1,
+    0,
+    1
+  ]);
+  const indices = new Uint16Array([
+    0,
+    1,
+    2,
+    0,
+    2,
+    3,
+    4,
+    5,
+    6,
+    4,
+    6,
+    7,
+    8,
+    9,
+    10,
+    8,
+    10,
+    11,
+    12,
+    13,
+    14,
+    12,
+    14,
+    15,
+    16,
+    17,
+    18,
+    16,
+    18,
+    19,
+    20,
+    21,
+    22,
+    20,
+    22,
+    23
+  ]);
+  return { positions, normals, uvs, indices };
+}
+function generateSplineGeometry(points, radii, radialSegments = 32, lengthSteps = 12, lod) {
+  if (lod) {
+    const preset = LOD_PRESETS[lod].spline;
+    radialSegments = preset.radialSegments;
+    lengthSteps = preset.lengthSteps;
+  }
+  if (points.length < 2) return fallbackBox();
+  const positions = [];
+  const normals = [];
+  const uvs = [];
+  const indices = [];
+  const pathPoints = [];
+  const pathRadii = [];
+  const numSegments = points.length - 1;
+  for (let seg = 0; seg < numSegments; seg++) {
+    const p0 = points[Math.max(0, seg - 1)];
+    const p1 = points[seg];
+    const p2 = points[Math.min(points.length - 1, seg + 1)];
+    const p3 = points[Math.min(points.length - 1, seg + 2)];
+    const r1 = radii[seg] ?? radii[radii.length - 1] ?? 0.1;
+    const r2 = radii[seg + 1] ?? radii[radii.length - 1] ?? 0.1;
+    const steps = seg === numSegments - 1 ? lengthSteps + 1 : lengthSteps;
+    for (let i = 0; i < steps; i++) {
+      const t = i / lengthSteps;
+      pathPoints.push(catmullRom(p0, p1, p2, p3, t));
+      pathRadii.push(r1 + (r2 - r1) * t);
+    }
+  }
+  const totalRings = pathPoints.length;
+  let prevNormal = [0, 0, 0];
+  for (let ring = 0; ring < totalRings; ring++) {
+    const p = pathPoints[ring];
+    const radius = pathRadii[ring];
+    const v = ring / (totalRings - 1);
+    let tangent;
+    if (ring === 0) {
+      tangent = vec3SubArray(pathPoints[1], pathPoints[0]);
+    } else if (ring === totalRings - 1) {
+      tangent = vec3SubArray(pathPoints[totalRings - 1], pathPoints[totalRings - 2]);
+    } else {
+      tangent = vec3SubArray(pathPoints[ring + 1], pathPoints[ring - 1]);
+    }
+    vec3NormalizeInPlace(tangent);
+    let normal;
+    let binormal;
+    if (ring === 0) {
+      if (Math.abs(tangent[0]) < 0.9) {
+        normal = vec3CrossArray(tangent, [1, 0, 0]);
+      } else {
+        normal = vec3CrossArray(tangent, [0, 1, 0]);
+      }
+      vec3NormalizeInPlace(normal);
+      binormal = vec3CrossArray(tangent, normal);
+      vec3NormalizeInPlace(binormal);
+    } else {
+      normal = vec3SubArray(
+        prevNormal,
+        vec3ScaleArray(
+          tangent,
+          prevNormal[0] * tangent[0] + prevNormal[1] * tangent[1] + prevNormal[2] * tangent[2]
+        )
+      );
+      const nLen = vec3NormalizeInPlace(normal);
+      if (nLen < 1e-6) normal = [...prevNormal];
+      binormal = vec3CrossArray(tangent, normal);
+      vec3NormalizeInPlace(binormal);
+    }
+    prevNormal = normal;
+    for (let i = 0; i <= radialSegments; i++) {
+      const u = i / radialSegments;
+      const theta = u * Math.PI * 2;
+      const cosT = Math.cos(theta);
+      const sinT = Math.sin(theta);
+      const nx = normal[0] * cosT + binormal[0] * sinT;
+      const ny = normal[1] * cosT + binormal[1] * sinT;
+      const nz = normal[2] * cosT + binormal[2] * sinT;
+      positions.push(p[0] + nx * radius, p[1] + ny * radius, p[2] + nz * radius);
+      normals.push(nx, ny, nz);
+      uvs.push(u, v);
+    }
+  }
+  const ringVerts = radialSegments + 1;
+  for (let ring = 0; ring < totalRings - 1; ring++) {
+    for (let i = 0; i < radialSegments; i++) {
+      const a = ring * ringVerts + i;
+      const b = a + ringVerts;
+      indices.push(a, b, a + 1);
+      indices.push(b, b + 1, a + 1);
+    }
+  }
+  const startCenter = positions.length / 3;
+  const sp = pathPoints[0];
+  const startTangent = vec3SubArray(pathPoints[1], pathPoints[0]);
+  vec3NormalizeInPlace(startTangent);
+  positions.push(sp[0], sp[1], sp[2]);
+  normals.push(-startTangent[0], -startTangent[1], -startTangent[2]);
+  uvs.push(0.5, 0);
+  for (let i = 0; i < radialSegments; i++) {
+    indices.push(startCenter, i + 1, i);
+  }
+  const endCenter = positions.length / 3;
+  const ep = pathPoints[totalRings - 1];
+  const endTangent = vec3SubArray(pathPoints[totalRings - 1], pathPoints[totalRings - 2]);
+  vec3NormalizeInPlace(endTangent);
+  positions.push(ep[0], ep[1], ep[2]);
+  normals.push(endTangent[0], endTangent[1], endTangent[2]);
+  uvs.push(0.5, 1);
+  const lastRingStart = (totalRings - 1) * ringVerts;
+  for (let i = 0; i < radialSegments; i++) {
+    indices.push(endCenter, lastRingStart + i, lastRingStart + i + 1);
+  }
+  const vertexCount = positions.length / 3;
+  const IndexArrayType = vertexCount > 65535 ? Uint32Array : Uint16Array;
+  return {
+    positions: new Float32Array(positions),
+    normals: new Float32Array(normals),
+    uvs: new Float32Array(uvs),
+    indices: new IndexArrayType(indices)
+  };
+}
+var MC_EDGE_TABLE = [
+  0,
+  265,
+  515,
+  778,
+  1030,
+  1295,
+  1541,
+  1804,
+  2060,
+  2309,
+  2575,
+  2822,
+  3082,
+  3331,
+  3593,
+  3840,
+  400,
+  153,
+  915,
+  666,
+  1430,
+  1183,
+  1941,
+  1692,
+  2460,
+  2197,
+  2975,
+  2710,
+  3482,
+  3219,
+  3993,
+  3728,
+  560,
+  825,
+  51,
+  314,
+  1590,
+  1855,
+  1077,
+  1340,
+  2620,
+  2869,
+  2111,
+  2358,
+  3642,
+  3891,
+  3129,
+  3376,
+  928,
+  681,
+  419,
+  170,
+  1958,
+  1711,
+  1445,
+  1196,
+  2988,
+  2725,
+  2479,
+  2214,
+  4010,
+  3747,
+  3497,
+  3232,
+  1120,
+  1385,
+  1635,
+  1898,
+  102,
+  367,
+  613,
+  876,
+  3180,
+  3429,
+  3695,
+  3942,
+  2154,
+  2403,
+  2665,
+  2912,
+  1520,
+  1273,
+  2035,
+  1786,
+  502,
+  255,
+  1013,
+  764,
+  3580,
+  3317,
+  4095,
+  3830,
+  2554,
+  2291,
+  3065,
+  2800,
+  1616,
+  1881,
+  1107,
+  1370,
+  598,
+  863,
+  85,
+  348,
+  3676,
+  3925,
+  3167,
+  3414,
+  2650,
+  2899,
+  2137,
+  2384,
+  1984,
+  1737,
+  1475,
+  1226,
+  966,
+  719,
+  453,
+  204,
+  4044,
+  3781,
+  3535,
+  3270,
+  3018,
+  2755,
+  2505,
+  2240,
+  2240,
+  2505,
+  2755,
+  3018,
+  3270,
+  3535,
+  3781,
+  4044,
+  204,
+  453,
+  719,
+  966,
+  1226,
+  1475,
+  1737,
+  1984,
+  2384,
+  2137,
+  2899,
+  2650,
+  3414,
+  3167,
+  3925,
+  3676,
+  348,
+  85,
+  863,
+  598,
+  1370,
+  1107,
+  1881,
+  1616,
+  2800,
+  3065,
+  2291,
+  2554,
+  3830,
+  4095,
+  3317,
+  3580,
+  764,
+  1013,
+  255,
+  502,
+  1786,
+  2035,
+  1273,
+  1520,
+  2912,
+  2665,
+  2403,
+  2154,
+  3942,
+  3695,
+  3429,
+  3180,
+  876,
+  613,
+  367,
+  102,
+  1898,
+  1635,
+  1385,
+  1120,
+  3232,
+  3497,
+  3747,
+  4010,
+  2214,
+  2479,
+  2725,
+  2988,
+  1196,
+  1445,
+  1711,
+  1958,
+  170,
+  419,
+  681,
+  928,
+  3376,
+  3129,
+  3891,
+  3642,
+  2358,
+  2111,
+  2869,
+  2620,
+  1340,
+  1077,
+  1855,
+  1590,
+  314,
+  51,
+  825,
+  560,
+  3728,
+  3993,
+  3219,
+  3482,
+  2710,
+  2975,
+  2197,
+  2460,
+  1692,
+  1941,
+  1183,
+  1430,
+  666,
+  915,
+  153,
+  400,
+  3840,
+  3593,
+  3331,
+  3082,
+  2822,
+  2575,
+  2309,
+  2060,
+  1804,
+  1541,
+  1295,
+  1030,
+  778,
+  515,
+  265,
+  0
+];
+var MC_TRI_TABLE = [
+  [-1],
+  [0, 8, 3, -1],
+  [0, 1, 9, -1],
+  [1, 8, 3, 9, 8, 1, -1],
+  [1, 2, 10, -1],
+  [0, 8, 3, 1, 2, 10, -1],
+  [9, 2, 10, 0, 2, 9, -1],
+  [2, 8, 3, 2, 10, 8, 10, 9, 8, -1],
+  [3, 11, 2, -1],
+  [0, 11, 2, 8, 11, 0, -1],
+  [1, 9, 0, 2, 3, 11, -1],
+  [1, 11, 2, 1, 9, 11, 9, 8, 11, -1],
+  [3, 10, 1, 11, 10, 3, -1],
+  [0, 10, 1, 0, 8, 10, 8, 11, 10, -1],
+  [3, 9, 0, 3, 11, 9, 11, 10, 9, -1],
+  [9, 8, 10, 10, 8, 11, -1],
+  [4, 7, 8, -1],
+  [4, 3, 0, 7, 3, 4, -1],
+  [0, 1, 9, 8, 4, 7, -1],
+  [4, 1, 9, 4, 7, 1, 7, 3, 1, -1],
+  [1, 2, 10, 8, 4, 7, -1],
+  [3, 4, 7, 3, 0, 4, 1, 2, 10, -1],
+  [9, 2, 10, 9, 0, 2, 8, 4, 7, -1],
+  [2, 10, 9, 2, 9, 7, 2, 7, 3, 7, 9, 4, -1],
+  [8, 4, 7, 3, 11, 2, -1],
+  [11, 4, 7, 11, 2, 4, 2, 0, 4, -1],
+  [9, 0, 1, 8, 4, 7, 2, 3, 11, -1],
+  [4, 7, 11, 9, 4, 11, 9, 11, 2, 9, 2, 1, -1],
+  [3, 10, 1, 3, 11, 10, 7, 8, 4, -1],
+  [1, 11, 10, 1, 4, 11, 1, 0, 4, 7, 11, 4, -1],
+  [4, 7, 8, 9, 0, 11, 9, 11, 10, 11, 0, 3, -1],
+  [4, 7, 11, 4, 11, 9, 9, 11, 10, -1],
+  [9, 5, 4, -1],
+  [9, 5, 4, 0, 8, 3, -1],
+  [0, 5, 4, 1, 5, 0, -1],
+  [8, 5, 4, 8, 3, 5, 3, 1, 5, -1],
+  [1, 2, 10, 9, 5, 4, -1],
+  [3, 0, 8, 1, 2, 10, 4, 9, 5, -1],
+  [5, 2, 10, 5, 4, 2, 4, 0, 2, -1],
+  [2, 10, 5, 3, 2, 5, 3, 5, 4, 3, 4, 8, -1],
+  [9, 5, 4, 2, 3, 11, -1],
+  [0, 11, 2, 0, 8, 11, 4, 9, 5, -1],
+  [0, 5, 4, 0, 1, 5, 2, 3, 11, -1],
+  [2, 1, 5, 2, 5, 8, 2, 8, 11, 4, 8, 5, -1],
+  [10, 3, 11, 10, 1, 3, 9, 5, 4, -1],
+  [4, 9, 5, 0, 8, 1, 8, 10, 1, 8, 11, 10, -1],
+  [5, 4, 0, 5, 0, 11, 5, 11, 10, 11, 0, 3, -1],
+  [5, 4, 8, 5, 8, 10, 10, 8, 11, -1],
+  [9, 7, 8, 5, 7, 9, -1],
+  [9, 3, 0, 9, 5, 3, 5, 7, 3, -1],
+  [0, 7, 8, 0, 1, 7, 1, 5, 7, -1],
+  [1, 5, 3, 3, 5, 7, -1],
+  [9, 7, 8, 9, 5, 7, 10, 1, 2, -1],
+  [10, 1, 2, 9, 5, 0, 5, 3, 0, 5, 7, 3, -1],
+  [8, 0, 2, 8, 2, 5, 8, 5, 7, 10, 5, 2, -1],
+  [2, 10, 5, 2, 5, 3, 3, 5, 7, -1],
+  [7, 9, 5, 7, 8, 9, 3, 11, 2, -1],
+  [9, 5, 7, 9, 7, 2, 9, 2, 0, 2, 7, 11, -1],
+  [2, 3, 11, 0, 1, 8, 1, 7, 8, 1, 5, 7, -1],
+  [11, 2, 1, 11, 1, 7, 7, 1, 5, -1],
+  [9, 5, 8, 8, 5, 7, 10, 1, 3, 10, 3, 11, -1],
+  [5, 7, 0, 5, 0, 9, 7, 11, 0, 1, 0, 10, 11, 10, 0, -1],
+  [11, 10, 0, 11, 0, 3, 10, 5, 0, 8, 0, 7, 5, 7, 0, -1],
+  [11, 10, 5, 7, 11, 5, -1],
+  [10, 6, 5, -1],
+  [0, 8, 3, 5, 10, 6, -1],
+  [9, 0, 1, 5, 10, 6, -1],
+  [1, 8, 3, 1, 9, 8, 5, 10, 6, -1],
+  [1, 6, 5, 2, 6, 1, -1],
+  [1, 6, 5, 1, 2, 6, 3, 0, 8, -1],
+  [9, 6, 5, 9, 0, 6, 0, 2, 6, -1],
+  [5, 9, 8, 5, 8, 2, 5, 2, 6, 3, 2, 8, -1],
+  [2, 3, 11, 10, 6, 5, -1],
+  [11, 0, 8, 11, 2, 0, 10, 6, 5, -1],
+  [0, 1, 9, 2, 3, 11, 5, 10, 6, -1],
+  [5, 10, 6, 1, 9, 2, 9, 11, 2, 9, 8, 11, -1],
+  [6, 3, 11, 6, 5, 3, 5, 1, 3, -1],
+  [0, 8, 11, 0, 11, 5, 0, 5, 1, 5, 11, 6, -1],
+  [3, 11, 6, 0, 3, 6, 0, 6, 5, 0, 5, 9, -1],
+  [6, 5, 9, 6, 9, 11, 11, 9, 8, -1],
+  [5, 10, 6, 4, 7, 8, -1],
+  [4, 3, 0, 4, 7, 3, 6, 5, 10, -1],
+  [1, 9, 0, 5, 10, 6, 8, 4, 7, -1],
+  [10, 6, 5, 1, 9, 7, 1, 7, 3, 7, 9, 4, -1],
+  [6, 1, 2, 6, 5, 1, 4, 7, 8, -1],
+  [1, 2, 5, 5, 2, 6, 3, 0, 4, 3, 4, 7, -1],
+  [8, 4, 7, 9, 0, 5, 0, 6, 5, 0, 2, 6, -1],
+  [7, 3, 9, 7, 9, 4, 3, 2, 9, 5, 9, 6, 2, 6, 9, -1],
+  [3, 11, 2, 7, 8, 4, 10, 6, 5, -1],
+  [5, 10, 6, 4, 7, 2, 4, 2, 0, 2, 7, 11, -1],
+  [0, 1, 9, 4, 7, 8, 2, 3, 11, 5, 10, 6, -1],
+  [9, 2, 1, 9, 11, 2, 9, 4, 11, 7, 11, 4, 5, 10, 6, -1],
+  [8, 4, 7, 3, 11, 5, 3, 5, 1, 5, 11, 6, -1],
+  [5, 1, 11, 5, 11, 6, 1, 0, 11, 7, 11, 4, 0, 4, 11, -1],
+  [0, 5, 9, 0, 6, 5, 0, 3, 6, 11, 6, 3, 8, 4, 7, -1],
+  [6, 5, 9, 6, 9, 11, 4, 7, 9, 7, 11, 9, -1],
+  [10, 4, 9, 6, 4, 10, -1],
+  [4, 10, 6, 4, 9, 10, 0, 8, 3, -1],
+  [10, 0, 1, 10, 6, 0, 6, 4, 0, -1],
+  [8, 3, 1, 8, 1, 6, 8, 6, 4, 6, 1, 10, -1],
+  [1, 4, 9, 1, 2, 4, 2, 6, 4, -1],
+  [3, 0, 8, 1, 2, 9, 2, 4, 9, 2, 6, 4, -1],
+  [0, 2, 4, 4, 2, 6, -1],
+  [8, 3, 2, 8, 2, 4, 4, 2, 6, -1],
+  [10, 4, 9, 10, 6, 4, 11, 2, 3, -1],
+  [0, 8, 2, 2, 8, 11, 4, 9, 10, 4, 10, 6, -1],
+  [3, 11, 2, 0, 1, 6, 0, 6, 4, 6, 1, 10, -1],
+  [6, 4, 1, 6, 1, 10, 4, 8, 1, 2, 1, 11, 8, 11, 1, -1],
+  [9, 6, 4, 9, 3, 6, 9, 1, 3, 11, 6, 3, -1],
+  [8, 11, 1, 8, 1, 0, 11, 6, 1, 9, 1, 4, 6, 4, 1, -1],
+  [3, 11, 6, 3, 6, 0, 0, 6, 4, -1],
+  [6, 4, 8, 11, 6, 8, -1],
+  [7, 10, 6, 7, 8, 10, 8, 9, 10, -1],
+  [0, 7, 3, 0, 10, 7, 0, 9, 10, 6, 7, 10, -1],
+  [10, 6, 7, 1, 10, 7, 1, 7, 8, 1, 8, 0, -1],
+  [10, 6, 7, 10, 7, 1, 1, 7, 3, -1],
+  [1, 2, 6, 1, 6, 8, 1, 8, 9, 8, 6, 7, -1],
+  [2, 6, 9, 2, 9, 1, 6, 7, 9, 0, 9, 3, 7, 3, 9, -1],
+  [7, 8, 0, 7, 0, 6, 6, 0, 2, -1],
+  [7, 3, 2, 6, 7, 2, -1],
+  [2, 3, 11, 10, 6, 8, 10, 8, 9, 8, 6, 7, -1],
+  [2, 0, 7, 2, 7, 11, 0, 9, 7, 6, 7, 10, 9, 10, 7, -1],
+  [1, 8, 0, 1, 7, 8, 1, 10, 7, 6, 7, 10, 2, 3, 11, -1],
+  [11, 2, 1, 11, 1, 7, 10, 6, 1, 6, 7, 1, -1],
+  [8, 9, 6, 8, 6, 7, 9, 1, 6, 11, 6, 3, 1, 3, 6, -1],
+  [0, 9, 1, 11, 6, 7, -1],
+  [7, 8, 0, 7, 0, 6, 3, 11, 0, 11, 6, 0, -1],
+  [7, 11, 6, -1],
+  [7, 6, 11, -1],
+  [3, 0, 8, 11, 7, 6, -1],
+  [0, 1, 9, 11, 7, 6, -1],
+  [8, 1, 9, 8, 3, 1, 11, 7, 6, -1],
+  [10, 1, 2, 6, 11, 7, -1],
+  [1, 2, 10, 3, 0, 8, 6, 11, 7, -1],
+  [2, 9, 0, 2, 10, 9, 6, 11, 7, -1],
+  [6, 11, 7, 2, 10, 3, 10, 8, 3, 10, 9, 8, -1],
+  [7, 2, 3, 6, 2, 7, -1],
+  [7, 0, 8, 7, 6, 0, 6, 2, 0, -1],
+  [2, 7, 6, 2, 3, 7, 0, 1, 9, -1],
+  [1, 6, 2, 1, 8, 6, 1, 9, 8, 8, 7, 6, -1],
+  [10, 7, 6, 10, 1, 7, 1, 3, 7, -1],
+  [10, 7, 6, 1, 7, 10, 1, 8, 7, 1, 0, 8, -1],
+  [0, 3, 7, 0, 7, 10, 0, 10, 9, 6, 10, 7, -1],
+  [7, 6, 10, 7, 10, 8, 8, 10, 9, -1],
+  [6, 8, 4, 11, 8, 6, -1],
+  [3, 6, 11, 3, 0, 6, 0, 4, 6, -1],
+  [8, 6, 11, 8, 4, 6, 9, 0, 1, -1],
+  [9, 4, 6, 9, 6, 3, 9, 3, 1, 11, 3, 6, -1],
+  [6, 8, 4, 6, 11, 8, 2, 10, 1, -1],
+  [1, 2, 10, 3, 0, 11, 0, 6, 11, 0, 4, 6, -1],
+  [4, 11, 8, 4, 6, 11, 0, 2, 9, 2, 10, 9, -1],
+  [10, 9, 3, 10, 3, 2, 9, 4, 3, 11, 3, 6, 4, 6, 3, -1],
+  [8, 2, 3, 8, 4, 2, 4, 6, 2, -1],
+  [0, 4, 2, 4, 6, 2, -1],
+  [1, 9, 0, 2, 3, 4, 2, 4, 6, 4, 3, 8, -1],
+  [1, 9, 4, 1, 4, 2, 2, 4, 6, -1],
+  [8, 1, 3, 8, 6, 1, 8, 4, 6, 6, 10, 1, -1],
+  [10, 1, 0, 10, 0, 6, 6, 0, 4, -1],
+  [4, 6, 3, 4, 3, 8, 6, 10, 3, 0, 3, 9, 10, 9, 3, -1],
+  [10, 9, 4, 6, 10, 4, -1],
+  [4, 9, 5, 7, 6, 11, -1],
+  [0, 8, 3, 4, 9, 5, 11, 7, 6, -1],
+  [5, 0, 1, 5, 4, 0, 7, 6, 11, -1],
+  [11, 7, 6, 8, 3, 4, 3, 5, 4, 3, 1, 5, -1],
+  [9, 5, 4, 10, 1, 2, 7, 6, 11, -1],
+  [6, 11, 7, 1, 2, 10, 0, 8, 3, 4, 9, 5, -1],
+  [7, 6, 11, 5, 4, 10, 4, 2, 10, 4, 0, 2, -1],
+  [3, 4, 8, 3, 5, 4, 3, 2, 5, 10, 5, 2, 11, 7, 6, -1],
+  [7, 2, 3, 7, 6, 2, 5, 4, 9, -1],
+  [9, 5, 4, 0, 8, 6, 0, 6, 2, 6, 8, 7, -1],
+  [3, 6, 2, 3, 7, 6, 1, 5, 0, 5, 4, 0, -1],
+  [6, 2, 8, 6, 8, 7, 2, 1, 8, 4, 8, 5, 1, 5, 8, -1],
+  [9, 5, 4, 10, 1, 6, 1, 7, 6, 1, 3, 7, -1],
+  [1, 6, 10, 1, 7, 6, 1, 0, 7, 8, 7, 0, 9, 5, 4, -1],
+  [4, 0, 10, 4, 10, 5, 0, 3, 10, 6, 10, 7, 3, 7, 10, -1],
+  [7, 6, 10, 7, 10, 8, 5, 4, 10, 4, 8, 10, -1],
+  [6, 9, 5, 6, 11, 9, 11, 8, 9, -1],
+  [3, 6, 11, 0, 6, 3, 0, 5, 6, 0, 9, 5, -1],
+  [0, 11, 8, 0, 5, 11, 0, 1, 5, 5, 6, 11, -1],
+  [6, 11, 3, 6, 3, 5, 5, 3, 1, -1],
+  [1, 2, 10, 9, 5, 11, 9, 11, 8, 11, 5, 6, -1],
+  [0, 11, 3, 0, 6, 11, 0, 9, 6, 5, 6, 9, 1, 2, 10, -1],
+  [11, 8, 5, 11, 5, 6, 8, 0, 5, 10, 5, 2, 0, 2, 5, -1],
+  [6, 11, 3, 6, 3, 5, 2, 10, 3, 10, 5, 3, -1],
+  [5, 8, 9, 5, 2, 8, 5, 6, 2, 3, 8, 2, -1],
+  [9, 5, 6, 9, 6, 0, 0, 6, 2, -1],
+  [1, 5, 8, 1, 8, 0, 5, 6, 8, 3, 8, 2, 6, 2, 8, -1],
+  [1, 5, 6, 2, 1, 6, -1],
+  [1, 3, 6, 1, 6, 10, 3, 8, 6, 5, 6, 9, 8, 9, 6, -1],
+  [10, 1, 0, 10, 0, 6, 9, 5, 0, 5, 6, 0, -1],
+  [0, 3, 8, 5, 6, 10, -1],
+  [10, 5, 6, -1],
+  [11, 5, 10, 7, 5, 11, -1],
+  [11, 5, 10, 11, 7, 5, 8, 3, 0, -1],
+  [5, 11, 7, 5, 10, 11, 1, 9, 0, -1],
+  [10, 7, 5, 10, 11, 7, 9, 8, 1, 8, 3, 1, -1],
+  [11, 1, 2, 11, 7, 1, 7, 5, 1, -1],
+  [0, 8, 3, 1, 2, 7, 1, 7, 5, 7, 2, 11, -1],
+  [9, 7, 5, 9, 2, 7, 9, 0, 2, 2, 11, 7, -1],
+  [7, 5, 2, 7, 2, 11, 5, 9, 2, 3, 2, 8, 9, 8, 2, -1],
+  [2, 5, 10, 2, 3, 5, 3, 7, 5, -1],
+  [8, 2, 0, 8, 5, 2, 8, 7, 5, 10, 2, 5, -1],
+  [9, 0, 1, 5, 10, 3, 5, 3, 7, 3, 10, 2, -1],
+  [9, 8, 2, 9, 2, 1, 8, 7, 2, 10, 2, 5, 7, 5, 2, -1],
+  [1, 3, 5, 3, 7, 5, -1],
+  [0, 8, 7, 0, 7, 1, 1, 7, 5, -1],
+  [9, 0, 3, 9, 3, 5, 5, 3, 7, -1],
+  [9, 8, 7, 5, 9, 7, -1],
+  [5, 8, 4, 5, 10, 8, 10, 11, 8, -1],
+  [5, 0, 4, 5, 11, 0, 5, 10, 11, 11, 3, 0, -1],
+  [0, 1, 9, 8, 4, 10, 8, 10, 11, 10, 4, 5, -1],
+  [10, 11, 4, 10, 4, 5, 11, 3, 4, 9, 4, 1, 3, 1, 4, -1],
+  [2, 5, 1, 2, 8, 5, 2, 11, 8, 4, 5, 8, -1],
+  [0, 4, 11, 0, 11, 3, 4, 5, 11, 2, 11, 1, 5, 1, 11, -1],
+  [0, 2, 5, 0, 5, 9, 2, 11, 5, 4, 5, 8, 11, 8, 5, -1],
+  [9, 4, 5, 2, 11, 3, -1],
+  [2, 5, 10, 3, 5, 2, 3, 4, 5, 3, 8, 4, -1],
+  [5, 10, 2, 5, 2, 4, 4, 2, 0, -1],
+  [3, 10, 2, 3, 5, 10, 3, 8, 5, 4, 5, 8, 0, 1, 9, -1],
+  [5, 10, 2, 5, 2, 4, 1, 9, 2, 9, 4, 2, -1],
+  [8, 4, 5, 8, 5, 3, 3, 5, 1, -1],
+  [0, 4, 5, 1, 0, 5, -1],
+  [8, 4, 5, 8, 5, 3, 9, 0, 5, 0, 3, 5, -1],
+  [9, 4, 5, -1],
+  [4, 11, 7, 4, 9, 11, 9, 10, 11, -1],
+  [0, 8, 3, 4, 9, 7, 9, 11, 7, 9, 10, 11, -1],
+  [1, 10, 11, 1, 11, 4, 1, 4, 0, 7, 4, 11, -1],
+  [3, 1, 4, 3, 4, 8, 1, 10, 4, 7, 4, 11, 10, 11, 4, -1],
+  [4, 11, 7, 9, 11, 4, 9, 2, 11, 9, 1, 2, -1],
+  [9, 7, 4, 9, 11, 7, 9, 1, 11, 2, 11, 1, 0, 8, 3, -1],
+  [11, 7, 4, 11, 4, 2, 2, 4, 0, -1],
+  [11, 7, 4, 11, 4, 2, 8, 3, 4, 3, 2, 4, -1],
+  [2, 9, 10, 2, 7, 9, 2, 3, 7, 7, 4, 9, -1],
+  [9, 10, 7, 9, 7, 4, 10, 2, 7, 0, 7, 8, 2, 8, 7, -1],
+  [3, 7, 10, 3, 10, 2, 7, 4, 10, 1, 10, 0, 4, 0, 10, -1],
+  [1, 10, 2, 8, 7, 4, -1],
+  [4, 9, 1, 4, 1, 7, 7, 1, 3, -1],
+  [4, 9, 1, 4, 1, 7, 0, 8, 1, 8, 7, 1, -1],
+  [4, 0, 3, 7, 4, 3, -1],
+  [4, 8, 7, -1],
+  [9, 10, 8, 10, 11, 8, -1],
+  [3, 0, 9, 3, 9, 11, 11, 9, 10, -1],
+  [0, 1, 10, 0, 10, 8, 8, 10, 11, -1],
+  [3, 1, 10, 11, 3, 10, -1],
+  [1, 2, 11, 1, 11, 9, 9, 11, 8, -1],
+  [3, 0, 9, 3, 9, 11, 1, 2, 9, 2, 11, 9, -1],
+  [0, 2, 11, 8, 0, 11, -1],
+  [3, 2, 11, -1],
+  [2, 3, 8, 2, 8, 10, 10, 8, 9, -1],
+  [9, 10, 2, 0, 9, 2, -1],
+  [2, 3, 8, 2, 8, 10, 0, 1, 8, 1, 10, 8, -1],
+  [1, 10, 2, -1],
+  [1, 3, 8, 9, 1, 8, -1],
+  [0, 9, 1, -1],
+  [0, 3, 8, -1],
+  [-1]
+];
+function generateHullGeometry(blobs, resolution = 24, threshold = 1, lod) {
+  if (blobs.length === 0) return fallbackBox();
+  const boundsPadding = lod ? LOD_PRESETS[lod].hull.boundsPadding : 1.3;
+  if (lod) {
+    const preset = LOD_PRESETS[lod].hull;
+    resolution = preset.resolution;
+  }
+  let minX = Infinity, minY = Infinity, minZ = Infinity;
+  let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
+  for (const b of blobs) {
+    minX = Math.min(minX, b.center[0] - b.radius[0] * boundsPadding);
+    minY = Math.min(minY, b.center[1] - b.radius[1] * boundsPadding);
+    minZ = Math.min(minZ, b.center[2] - b.radius[2] * boundsPadding);
+    maxX = Math.max(maxX, b.center[0] + b.radius[0] * boundsPadding);
+    maxY = Math.max(maxY, b.center[1] + b.radius[1] * boundsPadding);
+    maxZ = Math.max(maxZ, b.center[2] + b.radius[2] * boundsPadding);
+  }
+  const positions = [];
+  const normals = [];
+  const uvs = [];
+  const indices = [];
+  function evalField(x, y, z) {
+    let sum = 0;
+    for (const b of blobs) {
+      const dx2 = (x - b.center[0]) / b.radius[0];
+      const dy2 = (y - b.center[1]) / b.radius[1];
+      const dz2 = (z - b.center[2]) / b.radius[2];
+      const d2 = dx2 * dx2 + dy2 * dy2 + dz2 * dz2;
+      if (d2 > 1e-3) sum += 1 / d2;
+    }
+    return sum;
+  }
+  function evalGradient(x, y, z, eps = 0.01) {
+    return [
+      evalField(x + eps, y, z) - evalField(x - eps, y, z),
+      evalField(x, y + eps, z) - evalField(x, y - eps, z),
+      evalField(x, y, z + eps) - evalField(x, y, z - eps)
+    ];
+  }
+  const nx = resolution, ny = resolution, nz = resolution;
+  const dx = (maxX - minX) / nx;
+  const dy = (maxY - minY) / ny;
+  const dz = (maxZ - minZ) / nz;
+  const field = new Float32Array((nx + 1) * (ny + 1) * (nz + 1));
+  const idx3 = (ix, iy, iz) => ix + (nx + 1) * (iy + (ny + 1) * iz);
+  for (let iz = 0; iz <= nz; iz++) {
+    for (let iy = 0; iy <= ny; iy++) {
+      for (let ix = 0; ix <= nx; ix++) {
+        field[idx3(ix, iy, iz)] = evalField(minX + ix * dx, minY + iy * dy, minZ + iz * dz);
+      }
+    }
+  }
+  const vertexMap = /* @__PURE__ */ new Map();
+  const gridStride = nx + 1;
+  const gridSlice = gridStride * (ny + 1);
+  function interpVertex(ix1, iy1, iz1, v1, ix2, iy2, iz2, v2) {
+    const k1 = ix1 + iy1 * gridStride + iz1 * gridSlice;
+    const k2 = ix2 + iy2 * gridStride + iz2 * gridSlice;
+    const key = k1 < k2 ? `${k1}_${k2}` : `${k2}_${k1}`;
+    if (vertexMap.has(key)) return vertexMap.get(key);
+    const dv = v2 - v1;
+    const t = Math.abs(dv) < 1e-10 ? 0.5 : Math.max(0, Math.min(1, (threshold - v1) / dv));
+    const x = minX + (ix1 + t * (ix2 - ix1)) * dx;
+    const y = minY + (iy1 + t * (iy2 - iy1)) * dy;
+    const z = minZ + (iz1 + t * (iz2 - iz1)) * dz;
+    const gradEps = Math.min(dx, dy, dz) * 0.5;
+    const grad = evalGradient(x, y, z, gradEps);
+    const n = [-grad[0], -grad[1], -grad[2]];
+    vec3NormalizeInPlace(n);
+    const vertIdx = positions.length / 3;
+    positions.push(x, y, z);
+    normals.push(n[0], n[1], n[2]);
+    uvs.push(
+      0.5 + Math.atan2(n[2], n[0]) / (2 * Math.PI),
+      0.5 - Math.asin(Math.max(-1, Math.min(1, n[1]))) / Math.PI
+    );
+    vertexMap.set(key, vertIdx);
+    return vertIdx;
+  }
+  const edgeVerts = [
+    [0, 1],
+    [1, 2],
+    [2, 3],
+    [3, 0],
+    [4, 5],
+    [5, 6],
+    [6, 7],
+    [7, 4],
+    [0, 4],
+    [1, 5],
+    [2, 6],
+    [3, 7]
+  ];
+  const cornerOffsets = [
+    [0, 0, 0],
+    [1, 0, 0],
+    [1, 1, 0],
+    [0, 1, 0],
+    [0, 0, 1],
+    [1, 0, 1],
+    [1, 1, 1],
+    [0, 1, 1]
+  ];
+  for (let iz = 0; iz < nz; iz++) {
+    for (let iy = 0; iy < ny; iy++) {
+      for (let ix = 0; ix < nx; ix++) {
+        const cornerVals = [];
+        const cornerCoords = [];
+        let cubeIndex = 0;
+        for (let c = 0; c < 8; c++) {
+          const cx = ix + cornerOffsets[c][0];
+          const cy = iy + cornerOffsets[c][1];
+          const cz = iz + cornerOffsets[c][2];
+          const val = field[idx3(cx, cy, cz)];
+          cornerVals.push(val);
+          cornerCoords.push([cx, cy, cz]);
+          if (val >= threshold) cubeIndex |= 1 << c;
+        }
+        const edges = MC_EDGE_TABLE[cubeIndex];
+        if (edges === 0 || edges === void 0) continue;
+        const edgeVertices = new Array(12).fill(-1);
+        for (let e = 0; e < 12; e++) {
+          if (edges & 1 << e) {
+            const [c1, c2] = edgeVerts[e];
+            edgeVertices[e] = interpVertex(
+              cornerCoords[c1][0],
+              cornerCoords[c1][1],
+              cornerCoords[c1][2],
+              cornerVals[c1],
+              cornerCoords[c2][0],
+              cornerCoords[c2][1],
+              cornerCoords[c2][2],
+              cornerVals[c2]
+            );
+          }
+        }
+        const triRow = MC_TRI_TABLE[cubeIndex];
+        if (triRow) {
+          for (let t = 0; t < triRow.length; t += 3) {
+            const e0 = triRow[t], e1 = triRow[t + 1], e2 = triRow[t + 2];
+            if (e0 === -1) break;
+            if (edgeVertices[e0] >= 0 && edgeVertices[e1] >= 0 && edgeVertices[e2] >= 0) {
+              indices.push(edgeVertices[e0], edgeVertices[e1], edgeVertices[e2]);
+            }
+          }
+        }
+      }
+    }
+  }
+  if (positions.length === 0) return fallbackBox();
+  const vertexCount = positions.length / 3;
+  const IndexArrayType = vertexCount > 65535 ? Uint32Array : Uint16Array;
+  return {
+    positions: new Float32Array(positions),
+    normals: new Float32Array(normals),
+    uvs: new Float32Array(uvs),
+    indices: new IndexArrayType(indices)
+  };
+}
+function generateMembraneGeometry(anchors, subdivisions = 8, bulge = 0.15, lod) {
+  if (lod) {
+    subdivisions = LOD_PRESETS[lod].membrane.subdivisions;
+  }
+  if (anchors.length < 3) return fallbackBox();
+  const positions = [];
+  const normals = [];
+  const uvs = [];
+  const indices = [];
+  const center = [0, 0, 0];
+  for (const a of anchors) {
+    center[0] += a[0];
+    center[1] += a[1];
+    center[2] += a[2];
+  }
+  center[0] /= anchors.length;
+  center[1] /= anchors.length;
+  center[2] /= anchors.length;
+  const memNormal = [0, 0, 0];
+  for (let i = 0; i < anchors.length; i++) {
+    const a = anchors[i];
+    const b = anchors[(i + 1) % anchors.length];
+    const ca = vec3SubArray(a, center);
+    const cb = vec3SubArray(b, center);
+    const cross = vec3CrossArray(ca, cb);
+    memNormal[0] += cross[0];
+    memNormal[1] += cross[1];
+    memNormal[2] += cross[2];
+  }
+  vec3NormalizeInPlace(memNormal);
+  const numAnchors = anchors.length;
+  const centerIdx = 0;
+  positions.push(
+    center[0] + memNormal[0] * bulge,
+    center[1] + memNormal[1] * bulge,
+    center[2] + memNormal[2] * bulge
+  );
+  normals.push(memNormal[0], memNormal[1], memNormal[2]);
+  uvs.push(0.5, 0.5);
+  for (let ring = 1; ring <= subdivisions; ring++) {
+    const t = ring / subdivisions;
+    const ringBulge = bulge * (1 - t * t);
+    for (let seg = 0; seg < numAnchors; seg++) {
+      const a0 = anchors[seg];
+      anchors[(seg + 1) % numAnchors];
+      const px = center[0] + (a0[0] - center[0]) * t;
+      const py = center[1] + (a0[1] - center[1]) * t;
+      const pz = center[2] + (a0[2] - center[2]) * t;
+      positions.push(
+        px + memNormal[0] * ringBulge,
+        py + memNormal[1] * ringBulge,
+        pz + memNormal[2] * ringBulge
+      );
+      const dx = px - center[0];
+      const dy = py - center[1];
+      const dz = pz - center[2];
+      const n = [
+        memNormal[0] + dx * bulge * 0.5,
+        memNormal[1] + dy * bulge * 0.5,
+        memNormal[2] + dz * bulge * 0.5
+      ];
+      vec3NormalizeInPlace(n);
+      normals.push(n[0], n[1], n[2]);
+      const angle = seg / numAnchors * Math.PI * 2;
+      uvs.push(0.5 + t * 0.5 * Math.cos(angle), 0.5 + t * 0.5 * Math.sin(angle));
+    }
+  }
+  for (let i = 0; i < numAnchors; i++) {
+    const next = (i + 1) % numAnchors;
+    indices.push(centerIdx, 1 + i, 1 + next);
+  }
+  for (let ring = 1; ring < subdivisions; ring++) {
+    const ringStart = 1 + (ring - 1) * numAnchors;
+    const nextRingStart = 1 + ring * numAnchors;
+    for (let i = 0; i < numAnchors; i++) {
+      const next = (i + 1) % numAnchors;
+      indices.push(ringStart + i, nextRingStart + i, nextRingStart + next);
+      indices.push(ringStart + i, nextRingStart + next, ringStart + next);
+    }
+  }
+  const triCount = indices.length;
+  for (let i = 0; i < triCount; i += 3) {
+    indices.push(indices[i], indices[i + 2], indices[i + 1]);
+  }
+  const vertexCount = positions.length / 3;
+  const IndexArrayType = vertexCount > 65535 ? Uint32Array : Uint16Array;
+  return {
+    positions: new Float32Array(positions),
+    normals: new Float32Array(normals),
+    uvs: new Float32Array(uvs),
+    indices: new IndexArrayType(indices)
+  };
+}
+
+export { generateHullGeometry, generateMembraneGeometry, generateSplineGeometry };
+//# sourceMappingURL=chunk-EKBKLK7P.js.map
+//# sourceMappingURL=chunk-EKBKLK7P.js.map