@forgeax/engine-geometry 0.1.19 → 0.1.21

package/dist/index.mjs

@@ -1114,6 +1114,9 @@ function normalizeMeshPayload(payload, refs) {
   if (payload === null || typeof payload !== "object" || Array.isArray(payload)) return void 0;
   const source = payload;
   if (source.kind !== "mesh") return void 0;
+  const sourceAttributes = source.attributes !== null && typeof source.attributes === "object" ? source.attributes : void 0;
+  const projection = sourceAttributes === void 0 ? void 0 : deriveVertexLayoutProjection(sourceAttributes);
+  const floatsPerVertex = projection === void 0 || projection.attributes.length === 0 ? PROCEDURAL_FLOATS_PER_VERTEX : projection.arrayStride / Float32Array.BYTES_PER_ELEMENT;
   return meshFromParts(
     {
       vertices: source.vertices,
@@ -1124,7 +1127,7 @@ function normalizeMeshPayload(payload, refs) {
       ...Array.isArray(source.materialSlots) ? { materialSlots: source.materialSlots } : {},
       ...source.morphTargets === void 0 ? {} : { morphTargets: source.morphTargets },
       ...source.morphWeights === void 0 ? {} : { morphWeights: source.morphWeights },
-      floatsPerVertex: PROCEDURAL_FLOATS_PER_VERTEX
+      floatsPerVertex
     },
     refs
   );
@@ -2325,6 +2328,1884 @@ function createEdgesGeometry(source, thresholdAngleDegrees = DEFAULT_THRESHOLD_D
   );
   return lineMesh(edges.map(({ a, b }) => ({ a, b })));
 }
+var ATTRIBUTE_KEYS = [
+  "position",
+  "normal",
+  "uv",
+  "tangent",
+  "skinIndex",
+  "skinWeight",
+  "uv1",
+  "uv2",
+  "uv3",
+  "uv4",
+  "uv5",
+  "uv6",
+  "uv7",
+  "color"
+];
+var ATTRIBUTE_COMPONENTS = {
+  position: 3,
+  normal: 3,
+  uv: 2,
+  tangent: 4,
+  skinIndex: 4,
+  skinWeight: 4,
+  uv1: 2,
+  uv2: 2,
+  uv3: 2,
+  uv4: 2,
+  uv5: 2,
+  uv6: 2,
+  uv7: 2,
+  color: 4
+};
+var TOPOLOGIES = [
+  "point-list",
+  "line-list",
+  "line-strip",
+  "triangle-list",
+  "triangle-strip"
+];
+function failure(field, value, reason) {
+  return err(
+    new AssetError({
+      code: "asset-invalid-value",
+      expected: `valid MeshBuilder ${field}: ${reason}`,
+      hint: ASSET_ERROR_HINTS["asset-invalid-value"],
+      detail: { field, value, reason }
+    })
+  );
+}
+function sourceView(key, value) {
+  if (key === "skinIndex") {
+    if (value instanceof Uint16Array) return value;
+    if (value instanceof ArrayBuffer && value.byteLength % Uint16Array.BYTES_PER_ELEMENT === 0) {
+      return new Uint16Array(value);
+    }
+    return void 0;
+  }
+  if (value instanceof Float32Array) return value;
+  if (value instanceof ArrayBuffer && value.byteLength % Float32Array.BYTES_PER_ELEMENT === 0) {
+    return new Float32Array(value);
+  }
+  return void 0;
+}
+function cloneAttribute(key, value) {
+  const view = sourceView(key, value);
+  if (view === void 0) return void 0;
+  return view.slice();
+}
+function attributeKeys(attributes) {
+  return ATTRIBUTE_KEYS.filter((key) => attributes[key] !== void 0);
+}
+function appendArray(target, source) {
+  if (target instanceof Uint16Array && source instanceof Uint16Array) {
+    const output = new Uint16Array(target.length + source.length);
+    output.set(target, 0);
+    output.set(source, target.length);
+    return output;
+  }
+  if (target instanceof Float32Array && source instanceof Float32Array) {
+    const output = new Float32Array(target.length + source.length);
+    output.set(target, 0);
+    output.set(source, target.length);
+    return output;
+  }
+  return target;
+}
+function copySlots(slots) {
+  return (slots ?? [{ slotName: "Default" }]).map((slot) => ({
+    slotName: slot.slotName,
+    ...slot.sourceKey === void 0 ? {} : { sourceKey: slot.sourceKey },
+    ...slot.defaultMaterial === void 0 ? {} : { defaultMaterial: slot.defaultMaterial }
+  }));
+}
+function validateAttributeBatch(attributes) {
+  const keys = attributeKeys(attributes);
+  if (keys.length === 0)
+    return failure("attributes", [], "at least one canonical attribute is required");
+  const position = attributes.position;
+  if (position === void 0)
+    return failure("attributes.position", void 0, "position is required");
+  const positionView = sourceView("position", position);
+  if (positionView === void 0) {
+    return failure(
+      "attributes.position",
+      typeof position,
+      "position must use Float32Array or ArrayBuffer"
+    );
+  }
+  if (positionView.length === 0 || positionView.length % 3 !== 0) {
+    return failure(
+      "attributes.position",
+      positionView.length,
+      "position cardinality must be a non-zero multiple of 3"
+    );
+  }
+  const vertexCount = positionView.length / 3;
+  for (const key of keys) {
+    const value = attributes[key];
+    if (value === void 0) continue;
+    const view = sourceView(key, value);
+    if (view === void 0) {
+      return failure(
+        key,
+        typeof value,
+        key === "skinIndex" ? "storage must be Uint16Array" : "storage must be Float32Array"
+      );
+    }
+    const expectedLength = vertexCount * ATTRIBUTE_COMPONENTS[key];
+    if (view.length !== expectedLength) {
+      return failure(key, view.length, `cardinality must be ${expectedLength}`);
+    }
+    for (let elementIndex = 0; elementIndex < view.length; elementIndex += 1) {
+      const valueAt = view[elementIndex];
+      if (valueAt === void 0 || !Number.isFinite(valueAt)) {
+        return failure(key, valueAt, `${key}[${elementIndex}] must be finite`);
+      }
+      if (key === "skinIndex" && (!Number.isInteger(valueAt) || valueAt < 0 || valueAt > 65535)) {
+        return failure(key, valueAt, `${key}[${elementIndex}] must be an integer in [0, 65535]`);
+      }
+    }
+  }
+  return ok({ keys, vertexCount });
+}
+function validateSlots(slots) {
+  if (slots.length === 0)
+    return failure("materialSlots", slots.length, "at least one material slot is required");
+  const names = /* @__PURE__ */ new Set();
+  for (let index = 0; index < slots.length; index += 1) {
+    const slot = slots[index];
+    const name = slot?.slotName.trim() ?? "";
+    if (name.length === 0 || names.has(name)) {
+      return failure(`materialSlots[${index}].slotName`, name, "must be non-empty and unique");
+    }
+    names.add(name);
+  }
+  return ok(void 0);
+}
+function completedSubmeshes(requested, vertexCount, indexCount, materialSlotCount) {
+  const source = requested.length === 0 ? [
+    {
+      indexOffset: 0,
+      indexCount,
+      vertexCount,
+      topology: "triangle-list",
+      materialSlot: 0
+    }
+  ] : requested;
+  const output = [];
+  for (let index = 0; index < source.length; index += 1) {
+    const candidate = source[index];
+    if (candidate === void 0)
+      return failure(`submeshes[${index}]`, void 0, "entry is required");
+    const indexOffset = candidate.indexOffset ?? 0;
+    const submeshIndexCount = candidate.indexCount ?? (indexCount > 0 ? indexCount : 0);
+    const submeshVertexCount = candidate.vertexCount ?? vertexCount;
+    const topology = candidate.topology ?? "triangle-list";
+    const materialSlot = candidate.materialSlot ?? index;
+    if (!TOPOLOGIES.includes(topology)) {
+      return failure(
+        `submeshes[${index}].topology`,
+        topology,
+        "must be a WebGPU primitive topology"
+      );
+    }
+    if (!Number.isInteger(indexOffset) || indexOffset < 0 || !Number.isInteger(submeshIndexCount) || submeshIndexCount < 0 || !Number.isInteger(submeshVertexCount) || submeshVertexCount < 0 || submeshVertexCount > vertexCount || !Number.isInteger(materialSlot) || materialSlot < 0 || materialSlot >= materialSlotCount) {
+      return failure(
+        `submeshes[${index}]`,
+        JSON.stringify(candidate),
+        "range and material slot are invalid"
+      );
+    }
+    if (indexCount === 0 && (indexOffset !== 0 || submeshIndexCount !== 0)) {
+      return failure(
+        `submeshes[${index}]`,
+        JSON.stringify(candidate),
+        "non-indexed meshes use indexOffset=0 and indexCount=0"
+      );
+    }
+    if (indexCount > 0 && indexOffset + submeshIndexCount > indexCount) {
+      return failure(
+        `submeshes[${index}]`,
+        JSON.stringify(candidate),
+        "index range exceeds the accumulated index buffer"
+      );
+    }
+    if (indexCount === 0 && (topology === "line-strip" || topology === "triangle-strip")) {
+      return failure(
+        `submeshes[${index}].topology`,
+        topology,
+        "strip topology requires an index buffer"
+      );
+    }
+    output.push({
+      indexOffset,
+      indexCount: submeshIndexCount,
+      vertexCount: submeshVertexCount,
+      topology,
+      materialSlot
+    });
+  }
+  return ok(Object.freeze(output));
+}
+function createMeshBuilder(options = {}) {
+  const attributes = {};
+  const indices = [];
+  const submeshes = [];
+  const materialSlots = copySlots(options.materialSlots);
+  const appendVertices = (batch) => {
+    const checked = validateAttributeBatch(batch);
+    if (!checked.ok) return checked;
+    const incomingKeys = checked.value.keys;
+    const existingKeys = ATTRIBUTE_KEYS.filter((key) => attributes[key] !== void 0);
+    if (existingKeys.length > 0 && existingKeys.join("|") !== incomingKeys.join("|")) {
+      return failure(
+        "attributes",
+        incomingKeys.join(","),
+        "every appended batch must carry the same canonical keys"
+      );
+    }
+    for (const key of incomingKeys) {
+      const value = batch[key];
+      if (value === void 0) continue;
+      const cloned = cloneAttribute(key, value);
+      if (cloned === void 0) return failure(key, typeof value, "storage could not be cloned");
+      const previous = attributes[key];
+      attributes[key] = previous === void 0 ? cloned : appendArray(previous, cloned);
+    }
+    return ok(void 0);
+  };
+  const appendIndices = (batch) => {
+    for (let index = 0; index < batch.length; index += 1) {
+      const value = Number(batch[index]);
+      if (!Number.isInteger(value) || value < 0 || value > 4294967295) {
+        return failure("indices", value, `indices[${index}] must be an integer in [0, 2^32-1]`);
+      }
+      indices.push(value);
+    }
+    return ok(void 0);
+  };
+  const addSubmesh = (submesh) => {
+    if (submesh === null || typeof submesh !== "object") {
+      return failure("submeshes", submesh, "entry must be an object");
+    }
+    submeshes.push({ ...submesh });
+    return ok(void 0);
+  };
+  const build = () => {
+    const source = attributes;
+    const checked = validateAttributeBatch(source);
+    if (!checked.ok) return checked;
+    const slotCheck = validateSlots(materialSlots);
+    if (!slotCheck.ok) return slotCheck;
+    const vertexCount = checked.value.vertexCount;
+    const position = source.position;
+    if (position === void 0)
+      return failure("attributes.position", void 0, "position is required");
+    const positionView = sourceView("position", position);
+    if (!(positionView instanceof Float32Array)) {
+      return failure("attributes.position", typeof position, "position storage is invalid");
+    }
+    let maxIndex = 0;
+    for (const value of indices) maxIndex = Math.max(maxIndex, value);
+    const indexArray2 = indices.length === 0 ? void 0 : maxIndex <= 65535 ? new Uint16Array(indices) : new Uint32Array(indices);
+    if (indexArray2 !== void 0) {
+      for (let index = 0; index < indexArray2.length; index += 1) {
+        const value = indexArray2[index];
+        if (value === void 0 || value >= vertexCount) {
+          return failure(
+            "indices",
+            value ?? -1,
+            `indices[${index}] must be less than vertexCount (${vertexCount})`
+          );
+        }
+      }
+    }
+    const packed = packInterleavedVertexAttributes(source, vertexCount);
+    if (!packed.ok) return packed;
+    const ranges = completedSubmeshes(
+      submeshes,
+      vertexCount,
+      indexArray2?.length ?? 0,
+      materialSlots.length
+    );
+    if (!ranges.ok) return ranges;
+    const aabb = box3.fromPositions(box3.create(), positionView);
+    const copiedAttributes = {};
+    for (const key of checked.value.keys) {
+      const value = source[key];
+      if (value === void 0) continue;
+      const cloned = cloneAttribute(key, value);
+      if (cloned === void 0) return failure(key, typeof value, "storage could not be cloned");
+      if (key === "skinIndex") {
+        if (!(cloned instanceof Uint16Array)) {
+          return failure(key, typeof value, "skinIndex storage must be Uint16Array");
+        }
+        copiedAttributes.skinIndex = cloned;
+      } else {
+        if (!(cloned instanceof Float32Array)) {
+          return failure(key, typeof value, `${key} storage must be Float32Array`);
+        }
+        copiedAttributes[key] = cloned;
+      }
+    }
+    const mesh = {
+      kind: "mesh",
+      vertices: packed.value.vertices.slice(),
+      ...indexArray2 === void 0 ? {} : { indices: indexArray2.slice() },
+      attributes: copiedAttributes,
+      aabb: Float32Array.from(aabb),
+      submeshes: ranges.value,
+      materialSlots: Object.freeze(materialSlots.map((slot) => ({ ...slot })))
+    };
+    return ok(Object.freeze(mesh));
+  };
+  if (options.attributes !== void 0) {
+    const result = appendVertices(options.attributes);
+    if (!result.ok) {
+      const constructionError = result.error;
+      return {
+        appendVertices,
+        appendIndices,
+        addSubmesh,
+        build: () => err(constructionError)
+      };
+    }
+  }
+  if (options.indices !== void 0) {
+    const result = appendIndices(options.indices);
+    if (!result.ok) {
+      const constructionError = result.error;
+      return {
+        appendVertices,
+        appendIndices,
+        addSubmesh,
+        build: () => err(constructionError)
+      };
+    }
+  }
+  for (const submesh of options.submeshes ?? []) submeshes.push({ ...submesh });
+  return { appendVertices, appendIndices, addSubmesh, build };
+}
+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}`));
@@ -2384,6 +4265,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, createEdgesGeometry, createPlaneGeometry, createPrimitiveMesh, createSphereGeometry, createTorusGeometry, createWireframeGeometry, 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, createMeshBuilder, createPlaneGeometry, createPrimitiveMesh, createSphereGeometry, createTeapotGeometry, createTorusGeometry, createWireframeGeometry, deriveVertexBufferLayout, deriveVertexBufferLayoutFromProjection, deriveVertexLayoutProjection, deriveVertexLayoutProjectionFromMask, meshAssetContribution, meshAssetDecoder, meshAssetKind, meshFromInterleaved, packInterleavedVertexAttributes };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map