@forgeax/engine-geometry 0.1.7 → 0.1.20

package/dist/index.mjs

@@ -1936,6 +1936,1912 @@ function create2dRingGeometry(shape, thickness, resolutionOverride) {
     return invalid(`ring thickness=${thickness} exceeds shape extent=${extent}`);
   return ok(ring(outer, scaleAround(outer, factor)));
 }
+var WELD_EPSILON = 1e-4;
+var DEFAULT_THRESHOLD_DEGREES = 1;
+function parseFailure(field, value, reason) {
+  return new AssetError({
+    code: "asset-parse-failed",
+    expected: `a valid triangle-list MeshAsset: ${reason}`,
+    hint: ASSET_ERROR_HINTS["asset-parse-failed"],
+    detail: { field, value, reason }
+  });
+}
+function f32Bits(value) {
+  const buffer = new ArrayBuffer(4);
+  new Float32Array(buffer)[0] = value;
+  return new Uint32Array(buffer)[0];
+}
+function normalizedValue(value) {
+  return value === 0 ? 0 : value;
+}
+function exactKey(value) {
+  return value.map((component) => f32Bits(normalizedValue(component)).toString(16).padStart(8, "0")).join(":");
+}
+function weldComponent(value) {
+  const scaled = normalizedValue(value) / WELD_EPSILON;
+  return String(Math.round(scaled));
+}
+function weldKey(value) {
+  return value.map(weldComponent).join(":");
+}
+function endpoint(position) {
+  const value = [
+    normalizedValue(position[0]),
+    normalizedValue(position[1]),
+    normalizedValue(position[2])
+  ];
+  return { value, exactKey: exactKey(value), weldKey: weldKey(value) };
+}
+function compareText(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function compareEndpoint(left, right) {
+  return compareText(left.exactKey, right.exactKey);
+}
+function compareWireEdge(left, right) {
+  return compareEndpoint(left.a, right.a) || compareEndpoint(left.b, right.b);
+}
+function compareSurfaceEdge(left, right) {
+  return compareText(left.aWeldKey, right.aWeldKey) || compareText(left.bWeldKey, right.bWeldKey);
+}
+function readPosition(raw) {
+  return raw instanceof Float32Array ? raw : new Float32Array(raw);
+}
+function validatePosition(source) {
+  if (source === null || typeof source !== "object" || source.kind !== "mesh") {
+    return err(parseFailure("kind", source?.kind, "kind must be mesh"));
+  }
+  const attributes = source.attributes;
+  const raw = attributes?.position;
+  if (raw === void 0) {
+    return err(parseFailure("attributes.position", void 0, "position is required"));
+  }
+  if (raw instanceof ArrayBuffer) {
+    if (raw.byteLength % 4 !== 0) {
+      return err(
+        parseFailure(
+          "attributes.position",
+          raw.byteLength,
+          "ArrayBuffer byte length must align to f32"
+        )
+      );
+    }
+  } else if (!(raw instanceof Float32Array)) {
+    return err(
+      parseFailure(
+        "attributes.position",
+        raw === null ? null : typeof raw,
+        "position storage must be Float32Array or ArrayBuffer"
+      )
+    );
+  }
+  const position = readPosition(raw);
+  if (position.length % 3 !== 0) {
+    return err(
+      parseFailure(
+        "attributes.position",
+        position.length,
+        "position length must be divisible by 3"
+      )
+    );
+  }
+  for (let index = 0; index < position.length; index += 1) {
+    const value = position[index];
+    if (!Number.isFinite(value)) {
+      return err(parseFailure("attributes.position", value, `position[${index}] must be finite`));
+    }
+  }
+  return ok(position);
+}
+function validateThreshold(threshold) {
+  if (!Number.isFinite(threshold) || threshold < 0 || threshold > 180) {
+    return err(
+      parseFailure("thresholdAngleDegrees", threshold, "threshold must be finite and in [0, 180]")
+    );
+  }
+  return ok(threshold);
+}
+function validateSubmeshShape(source, positionCount) {
+  if (!Array.isArray(source.submeshes) || source.submeshes.length === 0) {
+    return err(parseFailure("submeshes", source.submeshes, "at least one submesh is required"));
+  }
+  const indexed = source.indices !== void 0;
+  if (!indexed && source.submeshes.length !== 1) {
+    return err(
+      parseFailure("submeshes", source.submeshes.length, "non-indexed meshes require one submesh")
+    );
+  }
+  if (!indexed && positionCount % 3 !== 0) {
+    return err(
+      parseFailure(
+        "attributes.position",
+        positionCount,
+        "non-indexed positions require triangle cardinality"
+      )
+    );
+  }
+  for (let index = 0; index < source.submeshes.length; index += 1) {
+    const submesh = source.submeshes[index];
+    if (submesh === void 0 || submesh === null || submesh.topology !== "triangle-list") {
+      return err(
+        parseFailure(
+          `submeshes[${index}].topology`,
+          submesh?.topology,
+          "topology must be triangle-list"
+        )
+      );
+    }
+    if (!Number.isInteger(submesh.indexOffset) || submesh.indexOffset < 0) {
+      return err(
+        parseFailure(
+          `submeshes[${index}].indexOffset`,
+          submesh.indexOffset,
+          "index offset must be a non-negative integer"
+        )
+      );
+    }
+    if (!Number.isInteger(submesh.indexCount) || submesh.indexCount < 0) {
+      return err(
+        parseFailure(
+          `submeshes[${index}].indexCount`,
+          submesh.indexCount,
+          "index count must be a non-negative integer"
+        )
+      );
+    }
+    if (!Number.isInteger(submesh.vertexCount) || submesh.vertexCount < 0 || submesh.vertexCount > positionCount) {
+      return err(
+        parseFailure(
+          `submeshes[${index}].vertexCount`,
+          submesh.vertexCount,
+          "vertex count must be an integer within position count"
+        )
+      );
+    }
+    if (submesh.indexCount % 3 !== 0) {
+      return err(
+        parseFailure(
+          `submeshes[${index}].indexCount`,
+          submesh.indexCount,
+          "index count must be divisible by 3"
+        )
+      );
+    }
+    if (!indexed && submesh.indexOffset !== 0) {
+      return err(
+        parseFailure(
+          `submeshes[${index}].indexOffset`,
+          submesh.indexOffset,
+          "non-indexed submesh index offset must be zero"
+        )
+      );
+    }
+    if (!indexed && submesh.indexCount !== 0) {
+      return err(
+        parseFailure(
+          `submeshes[${index}].indexCount`,
+          submesh.indexCount,
+          "non-indexed submesh index count must be zero"
+        )
+      );
+    }
+    if (!indexed && submesh.vertexCount !== positionCount) {
+      return err(
+        parseFailure(
+          `submeshes[${index}].vertexCount`,
+          submesh.vertexCount,
+          "non-indexed submesh must span all positions"
+        )
+      );
+    }
+  }
+  return ok(void 0);
+}
+function validateIndices(source, positionCount) {
+  const indices = source.indices;
+  if (indices === void 0) return ok(void 0);
+  if (!(indices instanceof Uint16Array) && !(indices instanceof Uint32Array)) {
+    return err(
+      parseFailure("indices", indices, "indices storage must be Uint16Array or Uint32Array")
+    );
+  }
+  for (let index = 0; index < source.submeshes.length; index += 1) {
+    const submesh = source.submeshes[index];
+    if (submesh === void 0) continue;
+    if (submesh.indexOffset + submesh.indexCount > indices.length) {
+      return err(
+        parseFailure(`submeshes[${index}]`, submesh, "submesh index range exceeds indices length")
+      );
+    }
+    for (let offset = submesh.indexOffset; offset < submesh.indexOffset + submesh.indexCount; offset += 1) {
+      const value = indices[offset];
+      if (!Number.isInteger(value) || value < 0 || value >= positionCount) {
+        return err(
+          parseFailure(`indices[${offset}]`, value, "index must address a position vertex")
+        );
+      }
+    }
+  }
+  return ok(void 0);
+}
+function cross(a, b) {
+  return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+}
+function subtract(a, b) {
+  return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+}
+function triangleNormal(a, b, c) {
+  const normal = cross(subtract(b, a), subtract(c, a));
+  const length = Math.hypot(normal[0], normal[1], normal[2]);
+  if (!Number.isFinite(length) || length === 0) return void 0;
+  return [normal[0] / length, normal[1] / length, normal[2] / length];
+}
+function positionAt(position, index) {
+  const base = index * 3;
+  return [position[base], position[base + 1], position[base + 2]];
+}
+function makeTriangle(position, indices) {
+  const a = endpoint(positionAt(position, indices[0]));
+  const b = endpoint(positionAt(position, indices[1]));
+  const c = endpoint(positionAt(position, indices[2]));
+  const normal = triangleNormal(a.value, b.value, c.value);
+  return normal === void 0 ? void 0 : { a, b, c, normal };
+}
+function collectTriangles(source, position) {
+  const triangles = [];
+  for (const submesh of source.submeshes) {
+    if (source.indices === void 0) {
+      for (let offset = 0; offset < submesh.vertexCount; offset += 3) {
+        const triangle = makeTriangle(position, [offset, offset + 1, offset + 2]);
+        if (triangle !== void 0) triangles.push(triangle);
+      }
+      continue;
+    }
+    for (let offset = submesh.indexOffset; offset < submesh.indexOffset + submesh.indexCount; offset += 3) {
+      const a = source.indices[offset];
+      const b = source.indices[offset + 1];
+      const c = source.indices[offset + 2];
+      const triangle = makeTriangle(position, [a, b, c]);
+      if (triangle !== void 0) triangles.push(triangle);
+    }
+  }
+  return triangles;
+}
+function prepare(source, threshold) {
+  const positionResult = validatePosition(source);
+  if (!positionResult.ok) return positionResult;
+  if (threshold !== void 0) {
+    const thresholdResult = validateThreshold(threshold);
+    if (!thresholdResult.ok) return thresholdResult;
+  }
+  const submeshResult = validateSubmeshShape(source, positionResult.value.length / 3);
+  if (!submeshResult.ok) return submeshResult;
+  const indexResult = validateIndices(source, positionResult.value.length / 3);
+  if (!indexResult.ok) return indexResult;
+  return ok({ triangles: collectTriangles(source, positionResult.value) });
+}
+function addWireEdge(edges, left, right) {
+  if (left.exactKey === right.exactKey) return;
+  const [a, b] = compareEndpoint(left, right) < 0 ? [left, right] : [right, left];
+  const key = `${a.exactKey}|${b.exactKey}`;
+  if (!edges.has(key)) edges.set(key, { a, b });
+}
+function collectWireEdges(triangles) {
+  const edges = /* @__PURE__ */ new Map();
+  for (const triangle of triangles) {
+    addWireEdge(edges, triangle.a, triangle.b);
+    addWireEdge(edges, triangle.b, triangle.c);
+    addWireEdge(edges, triangle.c, triangle.a);
+  }
+  return Array.from(edges.values()).sort(compareWireEdge);
+}
+function updateRepresentative(current, candidate) {
+  return compareEndpoint(candidate, current) < 0 ? candidate : current;
+}
+function addSurfaceEdge(edges, left, right, normal) {
+  if (left.weldKey === right.weldKey) return;
+  const leftFirst = compareText(left.weldKey, right.weldKey) < 0;
+  const a = leftFirst ? left : right;
+  const b = leftFirst ? right : left;
+  const key = `${a.weldKey}|${b.weldKey}`;
+  const current = edges.get(key);
+  if (current === void 0) {
+    edges.set(key, {
+      aWeldKey: a.weldKey,
+      bWeldKey: b.weldKey,
+      a,
+      b,
+      normals: [normal]
+    });
+    return;
+  }
+  current.a = updateRepresentative(current.a, a);
+  current.b = updateRepresentative(current.b, b);
+  current.normals.push(normal);
+}
+function collectSurfaceEdges(triangles) {
+  const edges = /* @__PURE__ */ new Map();
+  for (const triangle of triangles) {
+    addSurfaceEdge(edges, triangle.a, triangle.b, triangle.normal);
+    addSurfaceEdge(edges, triangle.b, triangle.c, triangle.normal);
+    addSurfaceEdge(edges, triangle.c, triangle.a, triangle.normal);
+  }
+  return Array.from(edges.values()).sort(compareSurfaceEdge);
+}
+function keepSurfaceEdge(edge, thresholdDegrees) {
+  if (edge.normals.length !== 2) return true;
+  const first = edge.normals[0];
+  const second = edge.normals[1];
+  if (first === void 0 || second === void 0) return true;
+  const dot = Math.min(
+    1,
+    Math.max(-1, first[0] * second[0] + first[1] * second[1] + first[2] * second[2])
+  );
+  return dot <= Math.cos(thresholdDegrees * Math.PI / 180);
+}
+function lineMesh(edges) {
+  const positions = new Float32Array(edges.length * 6);
+  for (let edgeIndex = 0; edgeIndex < edges.length; edgeIndex += 1) {
+    const edge = edges[edgeIndex];
+    positions.set(edge.a.value, edgeIndex * 6);
+    positions.set(edge.b.value, edgeIndex * 6 + 3);
+  }
+  const vertexCount = positions.length / 3;
+  const attributes = {
+    position: positions,
+    normal: new Float32Array(vertexCount * 3),
+    uv: new Float32Array(vertexCount * 2),
+    tangent: new Float32Array(vertexCount * 4)
+  };
+  const packed = packInterleavedVertexAttributes(attributes, vertexCount);
+  if (!packed.ok) return err(packed.error);
+  return ok({
+    kind: "mesh",
+    vertices: packed.value.vertices,
+    attributes,
+    submeshes: [
+      {
+        indexOffset: 0,
+        indexCount: 0,
+        vertexCount,
+        topology: "line-list",
+        materialSlot: 0
+      }
+    ],
+    materialSlots: [{ slotName: "Default" }],
+    aabb: box3.fromPositions(box3.create(), positions)
+  });
+}
+function createWireframeGeometry(source) {
+  const prepared = prepare(source);
+  if (!prepared.ok) return prepared;
+  return lineMesh(collectWireEdges(prepared.value.triangles));
+}
+function createEdgesGeometry(source, thresholdAngleDegrees = DEFAULT_THRESHOLD_DEGREES) {
+  const prepared = prepare(source, thresholdAngleDegrees);
+  if (!prepared.ok) return prepared;
+  const edges = collectSurfaceEdges(prepared.value.triangles).filter(
+    (edge) => keepSurfaceEdge(edge, thresholdAngleDegrees)
+  );
+  return lineMesh(edges.map(({ a, b }) => ({ a, b })));
+}
+var PATCHES = new Uint16Array([
+  0,
+  1,
+  2,
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  10,
+  11,
+  12,
+  13,
+  14,
+  15,
+  3,
+  16,
+  17,
+  18,
+  7,
+  19,
+  20,
+  21,
+  11,
+  22,
+  23,
+  24,
+  15,
+  25,
+  26,
+  27,
+  18,
+  28,
+  29,
+  30,
+  21,
+  31,
+  32,
+  33,
+  24,
+  34,
+  35,
+  36,
+  27,
+  37,
+  38,
+  39,
+  30,
+  40,
+  41,
+  0,
+  33,
+  42,
+  43,
+  4,
+  36,
+  44,
+  45,
+  8,
+  39,
+  46,
+  47,
+  12,
+  12,
+  13,
+  14,
+  15,
+  48,
+  49,
+  50,
+  51,
+  52,
+  53,
+  54,
+  55,
+  56,
+  57,
+  58,
+  59,
+  15,
+  25,
+  26,
+  27,
+  51,
+  60,
+  61,
+  62,
+  55,
+  63,
+  64,
+  65,
+  59,
+  66,
+  67,
+  68,
+  27,
+  37,
+  38,
+  39,
+  62,
+  69,
+  70,
+  71,
+  65,
+  72,
+  73,
+  74,
+  68,
+  75,
+  76,
+  77,
+  39,
+  46,
+  47,
+  12,
+  71,
+  78,
+  79,
+  48,
+  74,
+  80,
+  81,
+  52,
+  77,
+  82,
+  83,
+  56,
+  56,
+  57,
+  58,
+  59,
+  84,
+  85,
+  86,
+  87,
+  88,
+  89,
+  90,
+  91,
+  92,
+  93,
+  94,
+  95,
+  59,
+  66,
+  67,
+  68,
+  87,
+  96,
+  97,
+  98,
+  91,
+  99,
+  100,
+  101,
+  95,
+  102,
+  103,
+  104,
+  68,
+  75,
+  76,
+  77,
+  98,
+  105,
+  106,
+  107,
+  101,
+  108,
+  109,
+  110,
+  104,
+  111,
+  112,
+  113,
+  77,
+  82,
+  83,
+  56,
+  107,
+  114,
+  115,
+  84,
+  110,
+  116,
+  117,
+  88,
+  113,
+  118,
+  119,
+  92,
+  120,
+  121,
+  122,
+  123,
+  124,
+  125,
+  126,
+  127,
+  128,
+  129,
+  130,
+  131,
+  132,
+  133,
+  134,
+  135,
+  123,
+  136,
+  137,
+  120,
+  127,
+  138,
+  139,
+  124,
+  131,
+  140,
+  141,
+  128,
+  135,
+  142,
+  143,
+  132,
+  132,
+  133,
+  134,
+  135,
+  144,
+  145,
+  146,
+  147,
+  148,
+  149,
+  150,
+  151,
+  68,
+  152,
+  153,
+  154,
+  135,
+  142,
+  143,
+  132,
+  147,
+  155,
+  156,
+  144,
+  151,
+  157,
+  158,
+  148,
+  154,
+  159,
+  160,
+  68,
+  161,
+  162,
+  163,
+  164,
+  165,
+  166,
+  167,
+  168,
+  169,
+  170,
+  171,
+  172,
+  173,
+  174,
+  175,
+  176,
+  164,
+  177,
+  178,
+  161,
+  168,
+  179,
+  180,
+  165,
+  172,
+  181,
+  182,
+  169,
+  176,
+  183,
+  184,
+  173,
+  173,
+  174,
+  175,
+  176,
+  185,
+  186,
+  187,
+  188,
+  189,
+  190,
+  191,
+  192,
+  193,
+  194,
+  195,
+  196,
+  176,
+  183,
+  184,
+  173,
+  188,
+  197,
+  198,
+  185,
+  192,
+  199,
+  200,
+  189,
+  196,
+  201,
+  202,
+  193,
+  203,
+  203,
+  203,
+  203,
+  204,
+  205,
+  206,
+  207,
+  208,
+  208,
+  208,
+  208,
+  209,
+  210,
+  211,
+  212,
+  203,
+  203,
+  203,
+  203,
+  207,
+  213,
+  214,
+  215,
+  208,
+  208,
+  208,
+  208,
+  212,
+  216,
+  217,
+  218,
+  203,
+  203,
+  203,
+  203,
+  215,
+  219,
+  220,
+  221,
+  208,
+  208,
+  208,
+  208,
+  218,
+  222,
+  223,
+  224,
+  203,
+  203,
+  203,
+  203,
+  221,
+  225,
+  226,
+  204,
+  208,
+  208,
+  208,
+  208,
+  224,
+  227,
+  228,
+  209,
+  209,
+  210,
+  211,
+  212,
+  229,
+  230,
+  231,
+  232,
+  233,
+  234,
+  235,
+  236,
+  237,
+  238,
+  239,
+  240,
+  212,
+  216,
+  217,
+  218,
+  232,
+  241,
+  242,
+  243,
+  236,
+  244,
+  245,
+  246,
+  240,
+  247,
+  248,
+  249,
+  218,
+  222,
+  223,
+  224,
+  243,
+  250,
+  251,
+  252,
+  246,
+  253,
+  254,
+  255,
+  249,
+  256,
+  257,
+  258,
+  224,
+  227,
+  228,
+  209,
+  252,
+  259,
+  260,
+  229,
+  255,
+  261,
+  262,
+  233,
+  258,
+  263,
+  264,
+  237,
+  265,
+  265,
+  265,
+  265,
+  266,
+  267,
+  268,
+  269,
+  270,
+  271,
+  272,
+  273,
+  92,
+  119,
+  118,
+  113,
+  265,
+  265,
+  265,
+  265,
+  269,
+  274,
+  275,
+  276,
+  273,
+  277,
+  278,
+  279,
+  113,
+  112,
+  111,
+  104,
+  265,
+  265,
+  265,
+  265,
+  276,
+  280,
+  281,
+  282,
+  279,
+  283,
+  284,
+  285,
+  104,
+  103,
+  102,
+  95,
+  265,
+  265,
+  265,
+  265,
+  282,
+  286,
+  287,
+  266,
+  285,
+  288,
+  289,
+  270,
+  95,
+  94,
+  93,
+  92
+]);
+var CONTROL_POINTS = new Float32Array([
+  1.4,
+  0,
+  2.4,
+  1.4,
+  -0.784,
+  2.4,
+  0.784,
+  -1.4,
+  2.4,
+  0,
+  -1.4,
+  2.4,
+  1.3375,
+  0,
+  2.53125,
+  1.3375,
+  -0.749,
+  2.53125,
+  0.749,
+  -1.3375,
+  2.53125,
+  0,
+  -1.3375,
+  2.53125,
+  1.4375,
+  0,
+  2.53125,
+  1.4375,
+  -0.805,
+  2.53125,
+  0.805,
+  -1.4375,
+  2.53125,
+  0,
+  -1.4375,
+  2.53125,
+  1.5,
+  0,
+  2.4,
+  1.5,
+  -0.84,
+  2.4,
+  0.84,
+  -1.5,
+  2.4,
+  0,
+  -1.5,
+  2.4,
+  -0.784,
+  -1.4,
+  2.4,
+  -1.4,
+  -0.784,
+  2.4,
+  -1.4,
+  0,
+  2.4,
+  -0.749,
+  -1.3375,
+  2.53125,
+  -1.3375,
+  -0.749,
+  2.53125,
+  -1.3375,
+  0,
+  2.53125,
+  -0.805,
+  -1.4375,
+  2.53125,
+  -1.4375,
+  -0.805,
+  2.53125,
+  -1.4375,
+  0,
+  2.53125,
+  -0.84,
+  -1.5,
+  2.4,
+  -1.5,
+  -0.84,
+  2.4,
+  -1.5,
+  0,
+  2.4,
+  -1.4,
+  0.784,
+  2.4,
+  -0.784,
+  1.4,
+  2.4,
+  0,
+  1.4,
+  2.4,
+  -1.3375,
+  0.749,
+  2.53125,
+  -0.749,
+  1.3375,
+  2.53125,
+  0,
+  1.3375,
+  2.53125,
+  -1.4375,
+  0.805,
+  2.53125,
+  -0.805,
+  1.4375,
+  2.53125,
+  0,
+  1.4375,
+  2.53125,
+  -1.5,
+  0.84,
+  2.4,
+  -0.84,
+  1.5,
+  2.4,
+  0,
+  1.5,
+  2.4,
+  0.784,
+  1.4,
+  2.4,
+  1.4,
+  0.784,
+  2.4,
+  0.749,
+  1.3375,
+  2.53125,
+  1.3375,
+  0.749,
+  2.53125,
+  0.805,
+  1.4375,
+  2.53125,
+  1.4375,
+  0.805,
+  2.53125,
+  0.84,
+  1.5,
+  2.4,
+  1.5,
+  0.84,
+  2.4,
+  1.75,
+  0,
+  1.875,
+  1.75,
+  -0.98,
+  1.875,
+  0.98,
+  -1.75,
+  1.875,
+  0,
+  -1.75,
+  1.875,
+  2,
+  0,
+  1.35,
+  2,
+  -1.12,
+  1.35,
+  1.12,
+  -2,
+  1.35,
+  0,
+  -2,
+  1.35,
+  2,
+  0,
+  0.9,
+  2,
+  -1.12,
+  0.9,
+  1.12,
+  -2,
+  0.9,
+  0,
+  -2,
+  0.9,
+  -0.98,
+  -1.75,
+  1.875,
+  -1.75,
+  -0.98,
+  1.875,
+  -1.75,
+  0,
+  1.875,
+  -1.12,
+  -2,
+  1.35,
+  -2,
+  -1.12,
+  1.35,
+  -2,
+  0,
+  1.35,
+  -1.12,
+  -2,
+  0.9,
+  -2,
+  -1.12,
+  0.9,
+  -2,
+  0,
+  0.9,
+  -1.75,
+  0.98,
+  1.875,
+  -0.98,
+  1.75,
+  1.875,
+  0,
+  1.75,
+  1.875,
+  -2,
+  1.12,
+  1.35,
+  -1.12,
+  2,
+  1.35,
+  0,
+  2,
+  1.35,
+  -2,
+  1.12,
+  0.9,
+  -1.12,
+  2,
+  0.9,
+  0,
+  2,
+  0.9,
+  0.98,
+  1.75,
+  1.875,
+  1.75,
+  0.98,
+  1.875,
+  1.12,
+  2,
+  1.35,
+  2,
+  1.12,
+  1.35,
+  1.12,
+  2,
+  0.9,
+  2,
+  1.12,
+  0.9,
+  2,
+  0,
+  0.45,
+  2,
+  -1.12,
+  0.45,
+  1.12,
+  -2,
+  0.45,
+  0,
+  -2,
+  0.45,
+  1.5,
+  0,
+  0.225,
+  1.5,
+  -0.84,
+  0.225,
+  0.84,
+  -1.5,
+  0.225,
+  0,
+  -1.5,
+  0.225,
+  1.5,
+  0,
+  0.15,
+  1.5,
+  -0.84,
+  0.15,
+  0.84,
+  -1.5,
+  0.15,
+  0,
+  -1.5,
+  0.15,
+  -1.12,
+  -2,
+  0.45,
+  -2,
+  -1.12,
+  0.45,
+  -2,
+  0,
+  0.45,
+  -0.84,
+  -1.5,
+  0.225,
+  -1.5,
+  -0.84,
+  0.225,
+  -1.5,
+  0,
+  0.225,
+  -0.84,
+  -1.5,
+  0.15,
+  -1.5,
+  -0.84,
+  0.15,
+  -1.5,
+  0,
+  0.15,
+  -2,
+  1.12,
+  0.45,
+  -1.12,
+  2,
+  0.45,
+  0,
+  2,
+  0.45,
+  -1.5,
+  0.84,
+  0.225,
+  -0.84,
+  1.5,
+  0.225,
+  0,
+  1.5,
+  0.225,
+  -1.5,
+  0.84,
+  0.15,
+  -0.84,
+  1.5,
+  0.15,
+  0,
+  1.5,
+  0.15,
+  1.12,
+  2,
+  0.45,
+  2,
+  1.12,
+  0.45,
+  0.84,
+  1.5,
+  0.225,
+  1.5,
+  0.84,
+  0.225,
+  0.84,
+  1.5,
+  0.15,
+  1.5,
+  0.84,
+  0.15,
+  -1.6,
+  0,
+  2.025,
+  -1.6,
+  -0.3,
+  2.025,
+  -1.5,
+  -0.3,
+  2.25,
+  -1.5,
+  0,
+  2.25,
+  -2.3,
+  0,
+  2.025,
+  -2.3,
+  -0.3,
+  2.025,
+  -2.5,
+  -0.3,
+  2.25,
+  -2.5,
+  0,
+  2.25,
+  -2.7,
+  0,
+  2.025,
+  -2.7,
+  -0.3,
+  2.025,
+  -3,
+  -0.3,
+  2.25,
+  -3,
+  0,
+  2.25,
+  -2.7,
+  0,
+  1.8,
+  -2.7,
+  -0.3,
+  1.8,
+  -3,
+  -0.3,
+  1.8,
+  -3,
+  0,
+  1.8,
+  -1.5,
+  0.3,
+  2.25,
+  -1.6,
+  0.3,
+  2.025,
+  -2.5,
+  0.3,
+  2.25,
+  -2.3,
+  0.3,
+  2.025,
+  -3,
+  0.3,
+  2.25,
+  -2.7,
+  0.3,
+  2.025,
+  -3,
+  0.3,
+  1.8,
+  -2.7,
+  0.3,
+  1.8,
+  -2.7,
+  0,
+  1.575,
+  -2.7,
+  -0.3,
+  1.575,
+  -3,
+  -0.3,
+  1.35,
+  -3,
+  0,
+  1.35,
+  -2.5,
+  0,
+  1.125,
+  -2.5,
+  -0.3,
+  1.125,
+  -2.65,
+  -0.3,
+  0.9375,
+  -2.65,
+  0,
+  0.9375,
+  -2,
+  -0.3,
+  0.9,
+  -1.9,
+  -0.3,
+  0.6,
+  -1.9,
+  0,
+  0.6,
+  -3,
+  0.3,
+  1.35,
+  -2.7,
+  0.3,
+  1.575,
+  -2.65,
+  0.3,
+  0.9375,
+  -2.5,
+  0.3,
+  1.125,
+  -1.9,
+  0.3,
+  0.6,
+  -2,
+  0.3,
+  0.9,
+  1.7,
+  0,
+  1.425,
+  1.7,
+  -0.66,
+  1.425,
+  1.7,
+  -0.66,
+  0.6,
+  1.7,
+  0,
+  0.6,
+  2.6,
+  0,
+  1.425,
+  2.6,
+  -0.66,
+  1.425,
+  3.1,
+  -0.66,
+  0.825,
+  3.1,
+  0,
+  0.825,
+  2.3,
+  0,
+  2.1,
+  2.3,
+  -0.25,
+  2.1,
+  2.4,
+  -0.25,
+  2.025,
+  2.4,
+  0,
+  2.025,
+  2.7,
+  0,
+  2.4,
+  2.7,
+  -0.25,
+  2.4,
+  3.3,
+  -0.25,
+  2.4,
+  3.3,
+  0,
+  2.4,
+  1.7,
+  0.66,
+  0.6,
+  1.7,
+  0.66,
+  1.425,
+  3.1,
+  0.66,
+  0.825,
+  2.6,
+  0.66,
+  1.425,
+  2.4,
+  0.25,
+  2.025,
+  2.3,
+  0.25,
+  2.1,
+  3.3,
+  0.25,
+  2.4,
+  2.7,
+  0.25,
+  2.4,
+  2.8,
+  0,
+  2.475,
+  2.8,
+  -0.25,
+  2.475,
+  3.525,
+  -0.25,
+  2.49375,
+  3.525,
+  0,
+  2.49375,
+  2.9,
+  0,
+  2.475,
+  2.9,
+  -0.15,
+  2.475,
+  3.45,
+  -0.15,
+  2.5125,
+  3.45,
+  0,
+  2.5125,
+  2.8,
+  0,
+  2.4,
+  2.8,
+  -0.15,
+  2.4,
+  3.2,
+  -0.15,
+  2.4,
+  3.2,
+  0,
+  2.4,
+  3.525,
+  0.25,
+  2.49375,
+  2.8,
+  0.25,
+  2.475,
+  3.45,
+  0.15,
+  2.5125,
+  2.9,
+  0.15,
+  2.475,
+  3.2,
+  0.15,
+  2.4,
+  2.8,
+  0.15,
+  2.4,
+  0,
+  0,
+  3.15,
+  0.8,
+  0,
+  3.15,
+  0.8,
+  -0.45,
+  3.15,
+  0.45,
+  -0.8,
+  3.15,
+  0,
+  -0.8,
+  3.15,
+  0,
+  0,
+  2.85,
+  0.2,
+  0,
+  2.7,
+  0.2,
+  -0.112,
+  2.7,
+  0.112,
+  -0.2,
+  2.7,
+  0,
+  -0.2,
+  2.7,
+  -0.45,
+  -0.8,
+  3.15,
+  -0.8,
+  -0.45,
+  3.15,
+  -0.8,
+  0,
+  3.15,
+  -0.112,
+  -0.2,
+  2.7,
+  -0.2,
+  -0.112,
+  2.7,
+  -0.2,
+  0,
+  2.7,
+  -0.8,
+  0.45,
+  3.15,
+  -0.45,
+  0.8,
+  3.15,
+  0,
+  0.8,
+  3.15,
+  -0.2,
+  0.112,
+  2.7,
+  -0.112,
+  0.2,
+  2.7,
+  0,
+  0.2,
+  2.7,
+  0.45,
+  0.8,
+  3.15,
+  0.8,
+  0.45,
+  3.15,
+  0.112,
+  0.2,
+  2.7,
+  0.2,
+  0.112,
+  2.7,
+  0.4,
+  0,
+  2.55,
+  0.4,
+  -0.224,
+  2.55,
+  0.224,
+  -0.4,
+  2.55,
+  0,
+  -0.4,
+  2.55,
+  1.3,
+  0,
+  2.55,
+  1.3,
+  -0.728,
+  2.55,
+  0.728,
+  -1.3,
+  2.55,
+  0,
+  -1.3,
+  2.55,
+  1.3,
+  0,
+  2.4,
+  1.3,
+  -0.728,
+  2.4,
+  0.728,
+  -1.3,
+  2.4,
+  0,
+  -1.3,
+  2.4,
+  -0.224,
+  -0.4,
+  2.55,
+  -0.4,
+  -0.224,
+  2.55,
+  -0.4,
+  0,
+  2.55,
+  -0.728,
+  -1.3,
+  2.55,
+  -1.3,
+  -0.728,
+  2.55,
+  -1.3,
+  0,
+  2.55,
+  -0.728,
+  -1.3,
+  2.4,
+  -1.3,
+  -0.728,
+  2.4,
+  -1.3,
+  0,
+  2.4,
+  -0.4,
+  0.224,
+  2.55,
+  -0.224,
+  0.4,
+  2.55,
+  0,
+  0.4,
+  2.55,
+  -1.3,
+  0.728,
+  2.55,
+  -0.728,
+  1.3,
+  2.55,
+  0,
+  1.3,
+  2.55,
+  -1.3,
+  0.728,
+  2.4,
+  -0.728,
+  1.3,
+  2.4,
+  0,
+  1.3,
+  2.4,
+  0.224,
+  0.4,
+  2.55,
+  0.4,
+  0.224,
+  2.55,
+  0.728,
+  1.3,
+  2.55,
+  1.3,
+  0.728,
+  2.55,
+  0.728,
+  1.3,
+  2.4,
+  1.3,
+  0.728,
+  2.4,
+  0,
+  0,
+  0,
+  1.425,
+  0,
+  0,
+  1.425,
+  0.798,
+  0,
+  0.798,
+  1.425,
+  0,
+  0,
+  1.425,
+  0,
+  1.5,
+  0,
+  0.075,
+  1.5,
+  0.84,
+  0.075,
+  0.84,
+  1.5,
+  0.075,
+  0,
+  1.5,
+  0.075,
+  -0.798,
+  1.425,
+  0,
+  -1.425,
+  0.798,
+  0,
+  -1.425,
+  0,
+  0,
+  -0.84,
+  1.5,
+  0.075,
+  -1.5,
+  0.84,
+  0.075,
+  -1.5,
+  0,
+  0.075,
+  -1.425,
+  -0.798,
+  0,
+  -0.798,
+  -1.425,
+  0,
+  0,
+  -1.425,
+  0,
+  -1.5,
+  -0.84,
+  0.075,
+  -0.84,
+  -1.5,
+  0.075,
+  0,
+  -1.5,
+  0.075,
+  0.798,
+  -1.425,
+  0,
+  1.425,
+  -0.798,
+  0,
+  0.84,
+  -1.5,
+  0.075,
+  1.5,
+  -0.84,
+  0.075
+]);
+function basis(value) {
+  const inverse = 1 - value;
+  return [
+    inverse * inverse * inverse,
+    3 * value * inverse * inverse,
+    3 * value * value * inverse,
+    value * value * value
+  ];
+}
+function derivativeBasis(value) {
+  const inverse = 1 - value;
+  return [
+    -3 * inverse * inverse,
+    3 * inverse * inverse - 6 * value * inverse,
+    6 * value * inverse - 3 * value * value,
+    3 * value * value
+  ];
+}
+function evaluatePatch(surface, s, t, fitLid, blinn) {
+  const sb = basis(s);
+  const tb = basis(t);
+  const dsb = derivativeBasis(s);
+  const dtb = derivativeBasis(t);
+  const point = [0, 0, 0];
+  const ds = [0, 0, 0];
+  const dt = [0, 0, 0];
+  for (let row = 0; row < 4; row++) {
+    for (let column = 0; column < 4; column++) {
+      const control = PATCHES[surface * 16 + row * 4 + column] ?? 0;
+      const source = control * 3;
+      for (let axis = 0; axis < 3; axis++) {
+        const lidScale = fitLid && surface >= 20 && surface < 28 && axis !== 2 ? 1.077 : 1;
+        let value = (CONTROL_POINTS[source + axis] ?? 0) * lidScale;
+        if (!blinn && axis === 2) value *= 1.3;
+        const pointWeight = value * (sb[row] ?? 0) * (tb[column] ?? 0);
+        const dsWeight = value * (dsb[row] ?? 0) * (tb[column] ?? 0);
+        const dtWeight = value * (sb[row] ?? 0) * (dtb[column] ?? 0);
+        point[axis] = (point[axis] ?? 0) + pointWeight;
+        ds[axis] = (ds[axis] ?? 0) + dsWeight;
+        dt[axis] = (dt[axis] ?? 0) + dtWeight;
+      }
+    }
+  }
+  return { point, ds, dt };
+}
+function cross2(a, b) {
+  return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+}
+function normalize(value) {
+  const length = Math.hypot(value[0], value[1], value[2]);
+  return length > 0 ? [value[0] / length, value[1] / length, value[2] / length] : [0, 1, 0];
+}
+function createTeapotGeometry(size = 0.8, segments = 18, bottom = true, lid = true, body = true, fitLid = true, blinn = true) {
+  if (!Number.isFinite(size) || size <= 0 || !Number.isFinite(segments) || segments < 2) {
+    return err(
+      new AssetError({
+        code: "asset-parse-failed",
+        expected: "finite positive size and segments >= 2",
+        hint: ASSET_ERROR_HINTS["asset-parse-failed"],
+        detail: { field: "parameters", value: size, reason: `segments=${segments}` }
+      })
+    );
+  }
+  const steps = Math.max(2, Math.floor(segments));
+  const maxHeight = 3.15 * (blinn ? 1 : 1.3);
+  const maxHeight2 = maxHeight / 2;
+  const trueSize = size / maxHeight2;
+  const firstSurface = body ? 0 : 20;
+  const lastSurface = bottom ? 32 : 28;
+  const activeSurfaces = [];
+  for (let surface = firstSurface; surface < lastSurface; surface++) {
+    if (lid || surface < 20 || surface >= 28) activeSurfaces.push(surface);
+  }
+  const vertices = new Float32Array(
+    activeSurfaces.length * (steps + 1) * (steps + 1) * FACTORY_FLOATS_PER_VERTEX
+  );
+  const indices = [];
+  const stride = steps + 1;
+  let vertex = 0;
+  const positions = [];
+  for (const surface of activeSurfaces) {
+    const surfaceStart = vertex;
+    for (let sStep = 0; sStep <= steps; sStep++) {
+      const s = sStep / steps;
+      for (let tStep = 0; tStep <= steps; tStep++) {
+        const t = tStep / steps;
+        const evaluated = evaluatePatch(surface, s, t, fitLid, blinn);
+        const normalRaw = cross2(evaluated.dt, evaluated.ds);
+        const normal = evaluated.point[0] === 0 && evaluated.point[1] === 0 ? [0, evaluated.point[2] > maxHeight2 ? 1 : -1, 0] : normalize([normalRaw[0], normalRaw[2], -normalRaw[1]]);
+        const position = [
+          Math.fround(trueSize * evaluated.point[0]),
+          Math.fround(trueSize * (evaluated.point[2] - maxHeight2)),
+          Math.fround(-trueSize * evaluated.point[1])
+        ];
+        const base = vertex * FACTORY_FLOATS_PER_VERTEX;
+        vertices[base] = position[0];
+        vertices[base + 1] = position[1];
+        vertices[base + 2] = position[2];
+        vertices[base + 3] = normal[0];
+        vertices[base + 4] = normal[1];
+        vertices[base + 5] = normal[2];
+        vertices[base + 6] = 1 - t;
+        vertices[base + 7] = 1 - s;
+        positions.push(position);
+        vertex++;
+      }
+    }
+    for (let sStep = 0; sStep < steps; sStep++) {
+      for (let tStep = 0; tStep < steps; tStep++) {
+        const v1 = surfaceStart + sStep * stride + tStep;
+        const v2 = v1 + 1;
+        const v3 = v2 + stride;
+        const v4 = v1 + stride;
+        const same = (a, b) => positions[a]?.[0] === positions[b]?.[0] && positions[a]?.[1] === positions[b]?.[1] && positions[a]?.[2] === positions[b]?.[2];
+        if (!same(v1, v2) && !same(v1, v3) && !same(v2, v3)) indices.push(v1, v2, v3);
+        if (!same(v1, v3) && !same(v1, v4) && !same(v3, v4)) indices.push(v1, v3, v4);
+      }
+    }
+  }
+  const mesh = meshFromInterleaved(vertices, new Uint32Array(indices));
+  if (!mesh.ok) return mesh;
+  return ok({
+    ...mesh.value,
+    provenance: {
+      source: "three.js",
+      commit: "ad005397bbd15b0a9fcd5159c782eba56e1cba2a",
+      path: "examples/jsm/geometries/TeapotGeometry.js",
+      license: "MIT"
+    }
+  });
+}
 function createTorusGeometry(radius, tube, radialSegments = 8, tubularSegments = 24) {
   if (radius <= 0) return err(degenerate(`radius=${radius}`));
   if (tube <= 0) return err(degenerate(`tube=${tube}`));
@@ -1995,6 +3901,6 @@ function createTorusGeometry(radius, tube, radialSegments = 8, tubularSegments =
   return meshFromInterleaved(vertices, indices);
 }
 
-export { PROCEDURAL_FLOATS_PER_VERTEX, VertexAttributePackError, buildMeshAttributeMapForUvSets, compute2dBounds, computeTangentVec4, create2dGeometry, create2dRingGeometry, createBoxGeometry, createCapsuleGeometry, createConeGeometry, createCylinderGeometry, createPlaneGeometry, createPrimitiveMesh, createSphereGeometry, createTorusGeometry, deriveVertexBufferLayout, deriveVertexBufferLayoutFromProjection, deriveVertexLayoutProjection, deriveVertexLayoutProjectionFromMask, meshAssetContribution, meshAssetDecoder, meshAssetKind, meshFromInterleaved, packInterleavedVertexAttributes };
+export { PROCEDURAL_FLOATS_PER_VERTEX, VertexAttributePackError, buildMeshAttributeMapForUvSets, compute2dBounds, computeTangentVec4, create2dGeometry, create2dRingGeometry, createBoxGeometry, createCapsuleGeometry, createConeGeometry, createCylinderGeometry, createEdgesGeometry, createPlaneGeometry, createPrimitiveMesh, createSphereGeometry, createTeapotGeometry, createTorusGeometry, createWireframeGeometry, deriveVertexBufferLayout, deriveVertexBufferLayoutFromProjection, deriveVertexLayoutProjection, deriveVertexLayoutProjectionFromMask, meshAssetContribution, meshAssetDecoder, meshAssetKind, meshFromInterleaved, packInterleavedVertexAttributes };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map