@forgeax/engine-geometry 0.1.30 → 0.1.32

package/README.md

@@ -7,10 +7,11 @@ forgeax-engine. A **leaf** package: depends on `@forgeax/engine-ecs` (`Result`),
 
 ## 30-second self-introduction
 
-- **Surface**: 7 Three.js-r184-aligned 3D procedural factories
+- **Surface**: 10 reusable 3D procedural factories
   (`createBoxGeometry` / `createCapsuleGeometry` / `createConeGeometry` /
   `createCylinderGeometry` / `createPlaneGeometry` / `createSphereGeometry` /
-  `createTorusGeometry`),
+  `createTorusGeometry` / `createExtrusionGeometry` / `createSweepGeometry` /
+  `createRevolutionGeometry`),
   each returning `Result<MeshAsset, AssetError>`; the vertex-attribute-layout
   SSOT (`deriveVertexBufferLayout` / `buildMeshAttributeMapForUvSets` /
   `GpuVertexBufferLayoutEntry`); and the tangent + interleave helpers
@@ -125,7 +126,13 @@ const sphere = createSphereGeometry(1, 32, 24);
 // then hand the resulting Handle<MeshAsset> to MeshFilter.assetHandle.
 ```
 
-The 7 factories cover the most common procedural primitives. For an imported
+The primitive factories cover the common built-in shapes. For reusable authored
+geometry, `createExtrusionGeometry` ear-clips a simple concave 2D contour and
+adds cap and side normals, `createSweepGeometry` follows a 3D path with a
+circular profile, and `createRevolutionGeometry` turns a `(radius, height)`
+profile around the Y axis. Each operation validates finite input before
+allocating a MeshAsset and returns through the same tangent, layout, and AABB
+owners. For an imported
 glTF mesh, use `@forgeax/engine-gltf`; FBX follows the same source-plus-Meta
 route through `@forgeax/engine-fbx`. Runtime consumption is
 `@forgeax/engine-assets-runtime` after the owning importer has cooked the asset.
@@ -154,7 +161,7 @@ if (!filled.ok || !ring.ok) return;
 
 ## API surface
 
-### 7 procedural geometry factories
+### 10 procedural geometry factories
 
 Each returns `Result<MeshAsset, AssetError>`. Interleaved vertex layout:
 position (3xf32) + normal (3xf32) + uv (2xf32) = 8 floats/vertex at creation
@@ -170,6 +177,9 @@ time; expanded to the 12-float runtime layout (adds tangent vec4) by
 | `createPlaneGeometry` | `(w, h, wSeg?, hSeg?)` | 1 / dim; XY plane, +Z normal |
 | `createSphereGeometry` | `(radius, wSeg?, hSeg?)` | wSeg >= 3, hSeg >= 2 |
 | `createTorusGeometry` | `(radius, tube, radSeg?, tubSeg?)` | radSeg >= 3, tubSeg >= 3 |
+| `createExtrusionGeometry` | `(contour, depth)` | 3+ finite simple contour points, depth > 0 |
+| `createSweepGeometry` | `(path, radius, radialSeg?)` | 2+ distinct finite 3D points, radius > 0, radialSeg >= 3 |
+| `createRevolutionGeometry` | `(profile, radialSeg?)` | 2+ finite non-negative-radius points spanning height, radialSeg >= 3 |
 
 All factories populate `position` / `normal` / `uv` attributes with lowercase
 Three.js-r184 key naming. `VertexAttributeMap` also accepts optional `color`
@@ -233,7 +243,7 @@ them in sync.
 
 ## Three.js r184 mental alignment
 
-The 6 factory signatures mirror Three.js `BufferGeometry` constructors
+The seven primitive factory signatures mirror Three.js `BufferGeometry` constructors
 byte-for-byte: parameter order, attribute key lowercasing (`position` / `normal`
 / `uv`), and segment-count defaults. AI users migrating from Three.js can swap
 the import path and the return-shape check:

package/dist/__tests__/procedural.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=procedural.unit.test.d.ts.map

package/dist/__tests__/procedural.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"procedural.unit.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/procedural.unit.test.ts"],"names":[],"mappings":""}

package/dist/index.d.ts

@@ -10,6 +10,7 @@ export { compute2dBounds, create2dGeometry, create2dRingGeometry, type Shape2d,
 export { createEdgesGeometry, createWireframeGeometry } from './edges';
 export { createMeshBuilder, type MeshBuilder, type MeshBuilderOptions, type MeshBuilderSubmesh, } from './mesh-builder';
 export { createPlaneGeometry } from './plane';
+export { createExtrusionGeometry, createRevolutionGeometry, createSweepGeometry, type Vec2Point, type Vec3Point, } from './procedural';
 export { createSphereGeometry } from './sphere';
 export { computeTangentVec4 } from './tangent';
 export { createTeapotGeometry, type TeapotMeshAsset, type TeapotProvenance, } from './teapot';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA,YAAY,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC9E,OAAO,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC/F,OAAO,EACL,mBAAmB,EACnB,oBAAoB,EACpB,KAAK,iBAAiB,GACvB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,4BAA4B,GAC7B,MAAM,OAAO,CAAC;AACf,OAAO,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAC;AAClD,OAAO,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAC;AAC5C,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,oBAAoB,EACpB,KAAK,OAAO,EACZ,KAAK,aAAa,EAClB,KAAK,kBAAkB,EACvB,KAAK,WAAW,EAChB,KAAK,IAAI,GACV,MAAM,QAAQ,CAAC;AAEhB,OAAO,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAC;AACvE,OAAO,EACL,iBAAiB,EACjB,KAAK,WAAW,EAChB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,GACxB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAC9C,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAChD,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EACL,oBAAoB,EACpB,KAAK,eAAe,EACpB,KAAK,gBAAgB,GACtB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAC9C,OAAO,EACL,8BAA8B,EAC9B,4BAA4B,EAC5B,wBAAwB,EACxB,sCAAsC,EACtC,iBAAiB,EACjB,4BAA4B,EAC5B,oCAAoC,EACpC,KAAK,0BAA0B,EAC/B,KAAK,sBAAsB,EAC3B,+BAA+B,EAC/B,yBAAyB,EACzB,wBAAwB,EACxB,KAAK,sBAAsB,EAC3B,KAAK,+BAA+B,EACpC,KAAK,+BAA+B,GACrC,MAAM,2BAA2B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA,YAAY,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC9E,OAAO,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC/F,OAAO,EACL,mBAAmB,EACnB,oBAAoB,EACpB,KAAK,iBAAiB,GACvB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,4BAA4B,GAC7B,MAAM,OAAO,CAAC;AACf,OAAO,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAC;AAClD,OAAO,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAC;AAC5C,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,oBAAoB,EACpB,KAAK,OAAO,EACZ,KAAK,aAAa,EAClB,KAAK,kBAAkB,EACvB,KAAK,WAAW,EAChB,KAAK,IAAI,GACV,MAAM,QAAQ,CAAC;AAEhB,OAAO,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAC;AACvE,OAAO,EACL,iBAAiB,EACjB,KAAK,WAAW,EAChB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,GACxB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAC9C,OAAO,EACL,uBAAuB,EACvB,wBAAwB,EACxB,mBAAmB,EACnB,KAAK,SAAS,EACd,KAAK,SAAS,GACf,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAChD,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EACL,oBAAoB,EACpB,KAAK,eAAe,EACpB,KAAK,gBAAgB,GACtB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAC9C,OAAO,EACL,8BAA8B,EAC9B,4BAA4B,EAC5B,wBAAwB,EACxB,sCAAsC,EACtC,iBAAiB,EACjB,4BAA4B,EAC5B,oCAAoC,EACpC,KAAK,0BAA0B,EAC/B,KAAK,sBAAsB,EAC3B,+BAA+B,EAC/B,yBAAyB,EACzB,wBAAwB,EACxB,KAAK,sBAAsB,EAC3B,KAAK,+BAA+B,EACpC,KAAK,+BAA+B,GACrC,MAAM,2BAA2B,CAAC"}

package/dist/index.mjs

@@ -475,13 +475,13 @@ function deriveVertexLayoutProjectionFromMask(mask) {
   return ok(deriveVertexLayoutProjection(map));
 }
 function packInterleavedVertexAttributes(map, vertexCount) {
-  const invalid2 = (detail) => err(new VertexAttributePackError(detail));
+  const invalid3 = (detail) => err(new VertexAttributePackError(detail));
   if (!Number.isInteger(vertexCount) || vertexCount < 0) {
-    return invalid2({ field: "vertexCount", reason: "vertex-count-invalid", actual: vertexCount });
+    return invalid3({ field: "vertexCount", reason: "vertex-count-invalid", actual: vertexCount });
   }
   const projection = deriveVertexLayoutProjection(map);
   if (projection.attributes.length === 0) {
-    return invalid2({ field: "attributes", reason: "attributes-empty", actualCount: 0 });
+    return invalid3({ field: "attributes", reason: "attributes-empty", actualCount: 0 });
   }
   const output = new ArrayBuffer(projection.arrayStride * vertexCount);
   const outputFloats = new Float32Array(output);
@@ -493,7 +493,7 @@ function packInterleavedVertexAttributes(map, vertexCount) {
     const components = entry.byteLength / (uint16 ? 2 : 4);
     const bytesPerComponent = uint16 ? 2 : 4;
     if (sourceValue instanceof ArrayBuffer && sourceValue.byteLength % bytesPerComponent !== 0) {
-      return invalid2({
+      return invalid3({
         field: entry.key,
         reason: "attribute-cardinality-mismatch",
         vertexCount,
@@ -504,7 +504,7 @@ function packInterleavedVertexAttributes(map, vertexCount) {
     }
     const source = elementView(sourceValue, entry.format);
     if (source === void 0 || (uint16 ? storageOf(sourceValue) !== "uint16" && storageOf(sourceValue) !== "array-buffer" : storageOf(sourceValue) !== "float32" && storageOf(sourceValue) !== "array-buffer")) {
-      return invalid2({
+      return invalid3({
         field: entry.key,
         reason: "attribute-storage-invalid",
         expectedStorage: uint16 ? "uint16" : "float32",
@@ -513,7 +513,7 @@ function packInterleavedVertexAttributes(map, vertexCount) {
     }
     const expectedLength = vertexCount * components;
     if (source.length !== expectedLength) {
-      return invalid2({
+      return invalid3({
         field: entry.key,
         reason: "attribute-cardinality-mismatch",
         vertexCount,
@@ -526,7 +526,7 @@ function packInterleavedVertexAttributes(map, vertexCount) {
       for (let elementIndex = 0; elementIndex < source.length; elementIndex += 1) {
         const component = source[elementIndex];
         if (!Number.isFinite(component)) {
-          return invalid2({
+          return invalid3({
             field: "color",
             reason: "attribute-non-finite",
             elementIndex,
@@ -2706,6 +2706,356 @@ function createMeshBuilder(options = {}) {
   for (const submesh of options.submeshes ?? []) submeshes.push({ ...submesh });
   return { appendVertices, appendIndices, addSubmesh, build };
 }
+function invalid2(field, detail) {
+  return err(
+    new AssetError({
+      code: "asset-parse-failed",
+      expected: `valid procedural geometry input for ${field}`,
+      hint: ASSET_ERROR_HINTS["asset-parse-failed"],
+      detail: { field, value: detail, reason: detail }
+    })
+  );
+}
+function finitePoint2(point) {
+  return Number.isFinite(point.x) && Number.isFinite(point.y);
+}
+function cross2(a, b, c) {
+  return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
+}
+function signedArea(points) {
+  let value = 0;
+  for (let i = 0; i < points.length; i++) {
+    const a = points[i];
+    const b = points[(i + 1) % points.length];
+    value += a.x * b.y - b.x * a.y;
+  }
+  return value / 2;
+}
+function onSegment(a, b, p) {
+  return Math.min(a.x, b.x) <= p.x + 1e-8 && p.x <= Math.max(a.x, b.x) + 1e-8 && Math.min(a.y, b.y) <= p.y + 1e-8 && p.y <= Math.max(a.y, b.y) + 1e-8;
+}
+function edgesCross(a, b, c, d) {
+  const ab = cross2(a, b, c);
+  const abD = cross2(a, b, d);
+  const cdA = cross2(c, d, a);
+  const cdB = cross2(c, d, b);
+  if (Math.abs(ab) < 1e-8 && onSegment(a, b, c)) return true;
+  if (Math.abs(abD) < 1e-8 && onSegment(a, b, d)) return true;
+  if (Math.abs(cdA) < 1e-8 && onSegment(c, d, a)) return true;
+  if (Math.abs(cdB) < 1e-8 && onSegment(c, d, b)) return true;
+  return ab > 0 !== abD > 0 && cdA > 0 !== cdB > 0;
+}
+function selfIntersects(points) {
+  for (let i = 0; i < points.length; i++) {
+    const a = points[i];
+    const b = points[(i + 1) % points.length];
+    for (let j = i + 1; j < points.length; j++) {
+      if (j === i || (j + 1) % points.length === i || (i + 1) % points.length === j) continue;
+      const c = points[j];
+      const d = points[(j + 1) % points.length];
+      if (edgesCross(a, b, c, d)) return true;
+    }
+  }
+  return false;
+}
+function insideTriangle(a, b, c, point) {
+  return cross2(a, b, point) >= -1e-8 && cross2(b, c, point) >= -1e-8 && cross2(c, a, point) >= -1e-8;
+}
+function triangulate(points) {
+  const order = points.map((_, index) => index);
+  if (signedArea(points) < 0) order.reverse();
+  const triangles = [];
+  let guard = 0;
+  while (order.length > 3 && guard++ < points.length * points.length) {
+    let clipped = false;
+    for (let i = 0; i < order.length; i++) {
+      const previous = order[(i + order.length - 1) % order.length];
+      const current = order[i];
+      const next = order[(i + 1) % order.length];
+      if (cross2(
+        points[previous],
+        points[current],
+        points[next]
+      ) <= 1e-8)
+        continue;
+      let contains = false;
+      for (const candidate of order) {
+        if (candidate !== previous && candidate !== current && candidate !== next && insideTriangle(
+          points[previous],
+          points[current],
+          points[next],
+          points[candidate]
+        )) {
+          contains = true;
+          break;
+        }
+      }
+      if (contains) continue;
+      triangles.push(previous, current, next);
+      order.splice(i, 1);
+      clipped = true;
+      break;
+    }
+    if (!clipped) return void 0;
+  }
+  if (order.length !== 3) return void 0;
+  triangles.push(order[0], order[1], order[2]);
+  return triangles;
+}
+function pushVertex(vertices, position, normal, uv) {
+  const index = vertices.length / FACTORY_FLOATS_PER_VERTEX;
+  vertices.push(
+    position[0],
+    position[1],
+    position[2],
+    normal[0],
+    normal[1],
+    normal[2],
+    uv[0],
+    uv[1]
+  );
+  return index;
+}
+function pushTriangle(vertices, indices, a, b, c) {
+  indices.push(
+    pushVertex(vertices, a.p, a.n, a.uv),
+    pushVertex(vertices, b.p, b.n, b.uv),
+    pushVertex(vertices, c.p, c.n, c.uv)
+  );
+}
+function createExtrusionGeometry(contour, depth) {
+  if (!Number.isFinite(depth) || depth <= 0) return invalid2("depth", "must be positive and finite");
+  const points = contour.length > 1 && contour[0]?.x === contour[contour.length - 1]?.x && contour[0]?.y === contour[contour.length - 1]?.y ? contour.slice(0, -1) : [...contour];
+  if (points.length < 3 || points.some((point) => !finitePoint2(point)))
+    return invalid2("contour", "needs at least three finite points");
+  const area2 = signedArea(points);
+  if (Math.abs(area2) < 1e-8) return invalid2("contour", "area must be non-zero");
+  if (selfIntersects(points)) return invalid2("contour", "must not self-intersect");
+  const capTriangles = triangulate(points);
+  if (capTriangles === void 0) return invalid2("contour", "could not be triangulated");
+  const vertices = [];
+  const indices = [];
+  const half = depth / 2;
+  for (let i = 0; i < capTriangles.length; i += 3) {
+    const a = points[capTriangles[i]];
+    const b = points[capTriangles[i + 1]];
+    const c = points[capTriangles[i + 2]];
+    pushTriangle(
+      vertices,
+      indices,
+      { p: [a.x, a.y, half], n: [0, 0, 1], uv: [a.x, a.y] },
+      { p: [b.x, b.y, half], n: [0, 0, 1], uv: [b.x, b.y] },
+      { p: [c.x, c.y, half], n: [0, 0, 1], uv: [c.x, c.y] }
+    );
+    pushTriangle(
+      vertices,
+      indices,
+      { p: [c.x, c.y, -half], n: [0, 0, -1], uv: [c.x, c.y] },
+      { p: [b.x, b.y, -half], n: [0, 0, -1], uv: [b.x, b.y] },
+      { p: [a.x, a.y, -half], n: [0, 0, -1], uv: [a.x, a.y] }
+    );
+  }
+  let perimeter = 0;
+  for (let i = 0; i < points.length; i++) {
+    const a = points[i];
+    const b = points[(i + 1) % points.length];
+    perimeter += Math.hypot(b.x - a.x, b.y - a.y);
+  }
+  let distance = 0;
+  for (let i = 0; i < points.length; i++) {
+    const a = points[i];
+    const b = points[(i + 1) % points.length];
+    const edge = Math.hypot(b.x - a.x, b.y - a.y);
+    const u0 = perimeter === 0 ? 0 : distance / perimeter;
+    const u1 = perimeter === 0 ? 1 : (distance + edge) / perimeter;
+    const nx = b.y - a.y;
+    const ny = -(b.x - a.x);
+    const length = Math.hypot(nx, ny) || 1;
+    const normal = area2 >= 0 ? [nx / length, ny / length, 0] : [-nx / length, -ny / length, 0];
+    if (area2 >= 0) {
+      pushTriangle(
+        vertices,
+        indices,
+        { p: [a.x, a.y, -half], n: normal, uv: [u0, 0] },
+        { p: [b.x, b.y, -half], n: normal, uv: [u1, 0] },
+        { p: [b.x, b.y, half], n: normal, uv: [u1, 1] }
+      );
+      pushTriangle(
+        vertices,
+        indices,
+        { p: [a.x, a.y, -half], n: normal, uv: [u0, 0] },
+        { p: [b.x, b.y, half], n: normal, uv: [u1, 1] },
+        { p: [a.x, a.y, half], n: normal, uv: [u0, 1] }
+      );
+    } else {
+      pushTriangle(
+        vertices,
+        indices,
+        { p: [a.x, a.y, -half], n: normal, uv: [u0, 0] },
+        { p: [b.x, b.y, half], n: normal, uv: [u1, 1] },
+        { p: [b.x, b.y, -half], n: normal, uv: [u1, 0] }
+      );
+      pushTriangle(
+        vertices,
+        indices,
+        { p: [a.x, a.y, -half], n: normal, uv: [u0, 0] },
+        { p: [a.x, a.y, half], n: normal, uv: [u0, 1] },
+        { p: [b.x, b.y, half], n: normal, uv: [u1, 1] }
+      );
+    }
+    distance += edge;
+  }
+  return meshFromInterleaved(new Float32Array(vertices), new Uint32Array(indices));
+}
+function createSweepGeometry(path, radius, radialSegments = 12) {
+  if (!Number.isFinite(radius) || radius <= 0)
+    return invalid2("radius", "must be positive and finite");
+  const segments = radialSegments | 0;
+  if (path.length < 2 || path.some((point) => point.length !== 3 || point.some((value) => !Number.isFinite(value))))
+    return invalid2("path", "needs at least two finite 3D points");
+  if (segments < 3) return invalid2("radialSegments", "must be at least 3");
+  const first = path[0];
+  const last = path[path.length - 1];
+  const closed = path.length > 3 && Math.hypot(first[0] - last[0], first[1] - last[1], first[2] - last[2]) <= 1e-8;
+  for (let left = 0; left < path.length; left++) {
+    const a = path[left];
+    for (let right = left + 1; right < path.length; right++) {
+      const b = path[right];
+      if (closed && left === 0 && right === path.length - 1) continue;
+      if (Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]) <= 1e-8) {
+        return invalid2("path", "must not contain repeated points");
+      }
+    }
+  }
+  const lengths = [0];
+  for (let i = 1; i < path.length; i++) {
+    const previous = path[i - 1];
+    const current = path[i];
+    lengths.push(
+      lengths[i - 1] + Math.hypot(current[0] - previous[0], current[1] - previous[1], current[2] - previous[2])
+    );
+  }
+  const total = lengths[lengths.length - 1];
+  if (!(total > 0)) return invalid2("path", "must contain distinct points");
+  const vertices = [];
+  const indices = [];
+  for (let row = 0; row < path.length; row++) {
+    const point = path[row];
+    const previous = path[Math.max(0, row - 1)];
+    const next = path[Math.min(path.length - 1, row + 1)];
+    let tx = next[0] - previous[0];
+    let ty = next[1] - previous[1];
+    let tz = next[2] - previous[2];
+    const tangentLength = Math.hypot(tx, ty, tz) || 1;
+    tx /= tangentLength;
+    ty /= tangentLength;
+    tz /= tangentLength;
+    const reference = Math.abs(ty) < 0.95 ? [0, 1, 0] : [1, 0, 0];
+    let nx = ty * reference[2] - tz * reference[1];
+    let ny = tz * reference[0] - tx * reference[2];
+    let nz = tx * reference[1] - ty * reference[0];
+    const nLength = Math.hypot(nx, ny, nz) || 1;
+    nx /= nLength;
+    ny /= nLength;
+    nz /= nLength;
+    const bx = ty * nz - tz * ny;
+    const by = tz * nx - tx * nz;
+    const bz = tx * ny - ty * nx;
+    for (let column = 0; column <= segments; column++) {
+      const angle = column / segments * Math.PI * 2;
+      const radialX = Math.cos(angle) * nx + Math.sin(angle) * bx;
+      const radialY = Math.cos(angle) * ny + Math.sin(angle) * by;
+      const radialZ = Math.cos(angle) * nz + Math.sin(angle) * bz;
+      pushVertex(
+        vertices,
+        [point[0] + radialX * radius, point[1] + radialY * radius, point[2] + radialZ * radius],
+        [radialX, radialY, radialZ],
+        [column / segments, lengths[row] / total]
+      );
+    }
+  }
+  const stride = segments + 1;
+  const position = (index) => [
+    vertices[index * 8],
+    vertices[index * 8 + 1],
+    vertices[index * 8 + 2]
+  ];
+  for (let row = 0; row < path.length - 1; row++) {
+    for (let column = 0; column < segments; column++) {
+      const a = row * stride + column;
+      const b = a + 1;
+      const c = (row + 1) * stride + column + 1;
+      const d = (row + 1) * stride + column;
+      const p = position(a);
+      const q = position(b);
+      const r = position(c);
+      const ab = [q[0] - p[0], q[1] - p[1], q[2] - p[2]];
+      const ac = [r[0] - p[0], r[1] - p[1], r[2] - p[2]];
+      const normal = [
+        ab[1] * ac[2] - ab[2] * ac[1],
+        ab[2] * ac[0] - ab[0] * ac[2],
+        ab[0] * ac[1] - ab[1] * ac[0]
+      ];
+      const center = path[row];
+      const outward = [p[0] - center[0], p[1] - center[1], p[2] - center[2]];
+      const dot = normal[0] * outward[0] + normal[1] * outward[1] + normal[2] * outward[2];
+      if (dot > 0) indices.push(a, b, c, a, c, d);
+      else indices.push(a, c, b, a, d, c);
+    }
+  }
+  return meshFromInterleaved(new Float32Array(vertices), new Uint32Array(indices));
+}
+function createRevolutionGeometry(profile, radialSegments = 24) {
+  const segments = radialSegments | 0;
+  if (profile.length < 2 || profile.some((point) => !finitePoint2(point) || point.x < 0))
+    return invalid2("profile", "needs at least two finite points with non-negative radius");
+  if (segments < 3) return invalid2("radialSegments", "must be at least 3");
+  const first = profile[0];
+  if (first === void 0 || !profile.some((point) => point.y !== first.y))
+    return invalid2("profile", "must span a non-zero height");
+  for (let left = 0; left < profile.length; left++) {
+    const a = profile[left];
+    for (let right = left + 1; right < profile.length; right++) {
+      const b = profile[right];
+      if (Math.hypot(a.x - b.x, a.y - b.y) <= 1e-8) {
+        return invalid2("profile", "must not contain repeated points");
+      }
+    }
+  }
+  const vertices = [];
+  const indices = [];
+  for (let row = 0; row < profile.length; row++) {
+    const point = profile[row];
+    const previous = profile[Math.max(0, row - 1)];
+    const next = profile[Math.min(profile.length - 1, row + 1)];
+    const dr = next.x - previous.x;
+    const dy = next.y - previous.y;
+    const normalLength = Math.hypot(dy, dr) || 1;
+    for (let column = 0; column <= segments; column++) {
+      const u = column / segments;
+      const angle = u * Math.PI * 2;
+      const c = Math.cos(angle);
+      const s = Math.sin(angle);
+      pushVertex(
+        vertices,
+        [point.x * c, point.y, point.x * s],
+        [c * dy / normalLength, -dr / normalLength, s * dy / normalLength],
+        [u, row / (profile.length - 1)]
+      );
+    }
+  }
+  const stride = segments + 1;
+  for (let row = 0; row < profile.length - 1; row++) {
+    for (let column = 0; column < segments; column++) {
+      const a = row * stride + column;
+      const b = a + 1;
+      const c = (row + 1) * stride + column + 1;
+      const d = (row + 1) * stride + column;
+      indices.push(a, d, b, b, d, c);
+    }
+  }
+  return meshFromInterleaved(new Float32Array(vertices), new Uint32Array(indices));
+}
 var PATCHES = new Uint16Array([
   0,
   1,
@@ -4137,7 +4487,7 @@ function evaluatePatch(surface, s, t, fitLid, blinn) {
   }
   return { point, ds, dt };
 }
-function cross2(a, b) {
+function cross3(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) {
@@ -4179,7 +4529,7 @@ function createTeapotGeometry(size = 0.8, segments = 18, bottom = true, lid = tr
       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 normalRaw = cross3(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]),
@@ -4282,6 +4632,6 @@ function createTorusGeometry(radius, tube, radialSegments = 8, tubularSegments =
   return meshFromInterleaved(vertices, indices);
 }
 
-export { DEFAULT_VERTEX_ATTRIBUTE_MAP, PROCEDURAL_FLOATS_PER_VERTEX, SKIN_VERTEX_ATTRIBUTE_MAP, VertexAttributePackError, buildMeshAttributeMapForUvSets, compute2dBounds, computeTangentVec4, create2dGeometry, create2dRingGeometry, createBoxGeometry, createCapsuleGeometry, createConeGeometry, createCylinderGeometry, createEdgesGeometry, createMeshBuilder, createPlaneGeometry, createPrimitiveMesh, createProceduralMesh, createSphereGeometry, createTeapotGeometry, createTorusGeometry, createWireframeGeometry, decodeMeshBinary, deriveVertexBufferLayout, deriveVertexBufferLayoutFromProjection, deriveVertexCount, deriveVertexLayoutProjection, deriveVertexLayoutProjectionFromMask, meshAssetContribution, meshAssetDecoder, meshAssetKind, meshFromInterleaved, normalizeMeshPayload, packInterleavedVertexAttributes };
+export { DEFAULT_VERTEX_ATTRIBUTE_MAP, PROCEDURAL_FLOATS_PER_VERTEX, SKIN_VERTEX_ATTRIBUTE_MAP, VertexAttributePackError, buildMeshAttributeMapForUvSets, compute2dBounds, computeTangentVec4, create2dGeometry, create2dRingGeometry, createBoxGeometry, createCapsuleGeometry, createConeGeometry, createCylinderGeometry, createEdgesGeometry, createExtrusionGeometry, createMeshBuilder, createPlaneGeometry, createPrimitiveMesh, createProceduralMesh, createRevolutionGeometry, createSphereGeometry, createSweepGeometry, createTeapotGeometry, createTorusGeometry, createWireframeGeometry, decodeMeshBinary, deriveVertexBufferLayout, deriveVertexBufferLayoutFromProjection, deriveVertexCount, deriveVertexLayoutProjection, deriveVertexLayoutProjectionFromMask, meshAssetContribution, meshAssetDecoder, meshAssetKind, meshFromInterleaved, normalizeMeshPayload, packInterleavedVertexAttributes };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map