three-stdlib 2.22.7 → 2.22.8

package/dist/geometries/ParametricGeometries.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const ParametricGeometry = require("./ParametricGeometry.js");
+const ParametricGeometries = {
+  klein: function(v, u, target) {
+    u *= Math.PI;
+    v *= 2 * Math.PI;
+    u = u * 2;
+    let x, z;
+    if (u < Math.PI) {
+      x = 3 * Math.cos(u) * (1 + Math.sin(u)) + 2 * (1 - Math.cos(u) / 2) * Math.cos(u) * Math.cos(v);
+      z = -8 * Math.sin(u) - 2 * (1 - Math.cos(u) / 2) * Math.sin(u) * Math.cos(v);
+    } else {
+      x = 3 * Math.cos(u) * (1 + Math.sin(u)) + 2 * (1 - Math.cos(u) / 2) * Math.cos(v + Math.PI);
+      z = -8 * Math.sin(u);
+    }
+    const y = -2 * (1 - Math.cos(u) / 2) * Math.sin(v);
+    target.set(x, y, z);
+  },
+  plane: function(width, height) {
+    return function(u, v, target) {
+      const x = u * width;
+      const y = 0;
+      const z = v * height;
+      target.set(x, y, z);
+    };
+  },
+  mobius: function(u, t, target) {
+    u = u - 0.5;
+    const v = 2 * Math.PI * t;
+    const a = 2;
+    const x = Math.cos(v) * (a + u * Math.cos(v / 2));
+    const y = Math.sin(v) * (a + u * Math.cos(v / 2));
+    const z = u * Math.sin(v / 2);
+    target.set(x, y, z);
+  },
+  mobius3d: function(u, t, target) {
+    u *= Math.PI;
+    t *= 2 * Math.PI;
+    u = u * 2;
+    const phi = u / 2;
+    const major = 2.25, a = 0.125, b = 0.65;
+    let x = a * Math.cos(t) * Math.cos(phi) - b * Math.sin(t) * Math.sin(phi);
+    const z = a * Math.cos(t) * Math.sin(phi) + b * Math.sin(t) * Math.cos(phi);
+    const y = (major + x) * Math.sin(u);
+    x = (major + x) * Math.cos(u);
+    target.set(x, y, z);
+  }
+};
+ParametricGeometries.TubeGeometry = class TubeGeometry extends ParametricGeometry.ParametricGeometry {
+  constructor(path, segments = 64, radius = 1, segmentsRadius = 8, closed = false) {
+    const numpoints = segments + 1;
+    const frames = path.computeFrenetFrames(segments, closed), tangents = frames.tangents, normals = frames.normals, binormals = frames.binormals;
+    const position = new THREE.Vector3();
+    function ParametricTube(u, v, target) {
+      v *= 2 * Math.PI;
+      const i = Math.floor(u * (numpoints - 1));
+      path.getPointAt(u, position);
+      const normal = normals[i];
+      const binormal = binormals[i];
+      const cx = -radius * Math.cos(v);
+      const cy = radius * Math.sin(v);
+      position.x += cx * normal.x + cy * binormal.x;
+      position.y += cx * normal.y + cy * binormal.y;
+      position.z += cx * normal.z + cy * binormal.z;
+      target.copy(position);
+    }
+    super(ParametricTube, segments, segmentsRadius);
+    this.tangents = tangents;
+    this.normals = normals;
+    this.binormals = binormals;
+    this.path = path;
+    this.segments = segments;
+    this.radius = radius;
+    this.segmentsRadius = segmentsRadius;
+    this.closed = closed;
+  }
+};
+ParametricGeometries.TorusKnotGeometry = class TorusKnotGeometry extends ParametricGeometries.TubeGeometry {
+  constructor(radius = 200, tube = 40, segmentsT = 64, segmentsR = 8, p = 2, q = 3) {
+    class TorusKnotCurve extends THREE.Curve {
+      getPoint(t, optionalTarget = new THREE.Vector3()) {
+        const point = optionalTarget;
+        t *= Math.PI * 2;
+        const r = 0.5;
+        const x = (1 + r * Math.cos(q * t)) * Math.cos(p * t);
+        const y = (1 + r * Math.cos(q * t)) * Math.sin(p * t);
+        const z = r * Math.sin(q * t);
+        return point.set(x, y, z).multiplyScalar(radius);
+      }
+    }
+    const segments = segmentsT;
+    const radiusSegments = segmentsR;
+    const extrudePath = new TorusKnotCurve();
+    super(extrudePath, segments, tube, radiusSegments, true, false);
+    this.radius = radius;
+    this.tube = tube;
+    this.segmentsT = segmentsT;
+    this.segmentsR = segmentsR;
+    this.p = p;
+    this.q = q;
+  }
+};
+ParametricGeometries.SphereGeometry = class SphereGeometry extends ParametricGeometry.ParametricGeometry {
+  constructor(size, u, v) {
+    function sphere(u2, v2, target) {
+      u2 *= Math.PI;
+      v2 *= 2 * Math.PI;
+      const x = size * Math.sin(u2) * Math.cos(v2);
+      const y = size * Math.sin(u2) * Math.sin(v2);
+      const z = size * Math.cos(u2);
+      target.set(x, y, z);
+    }
+    super(sphere, u, v);
+  }
+};
+ParametricGeometries.PlaneGeometry = class PlaneGeometry extends ParametricGeometry.ParametricGeometry {
+  constructor(width, depth, segmentsWidth, segmentsDepth) {
+    function plane(u, v, target) {
+      const x = u * width;
+      const y = 0;
+      const z = v * depth;
+      target.set(x, y, z);
+    }
+    super(plane, segmentsWidth, segmentsDepth);
+  }
+};
+exports.ParametricGeometries = ParametricGeometries;

package/dist/geometries/ParametricGeometries.mjs

@@ -0,0 +1,129 @@
+import { Vector3, Curve } from "three";
+import { ParametricGeometry } from "./ParametricGeometry.mjs";
+const ParametricGeometries = {
+  klein: function(v, u, target) {
+    u *= Math.PI;
+    v *= 2 * Math.PI;
+    u = u * 2;
+    let x, z;
+    if (u < Math.PI) {
+      x = 3 * Math.cos(u) * (1 + Math.sin(u)) + 2 * (1 - Math.cos(u) / 2) * Math.cos(u) * Math.cos(v);
+      z = -8 * Math.sin(u) - 2 * (1 - Math.cos(u) / 2) * Math.sin(u) * Math.cos(v);
+    } else {
+      x = 3 * Math.cos(u) * (1 + Math.sin(u)) + 2 * (1 - Math.cos(u) / 2) * Math.cos(v + Math.PI);
+      z = -8 * Math.sin(u);
+    }
+    const y = -2 * (1 - Math.cos(u) / 2) * Math.sin(v);
+    target.set(x, y, z);
+  },
+  plane: function(width, height) {
+    return function(u, v, target) {
+      const x = u * width;
+      const y = 0;
+      const z = v * height;
+      target.set(x, y, z);
+    };
+  },
+  mobius: function(u, t, target) {
+    u = u - 0.5;
+    const v = 2 * Math.PI * t;
+    const a = 2;
+    const x = Math.cos(v) * (a + u * Math.cos(v / 2));
+    const y = Math.sin(v) * (a + u * Math.cos(v / 2));
+    const z = u * Math.sin(v / 2);
+    target.set(x, y, z);
+  },
+  mobius3d: function(u, t, target) {
+    u *= Math.PI;
+    t *= 2 * Math.PI;
+    u = u * 2;
+    const phi = u / 2;
+    const major = 2.25, a = 0.125, b = 0.65;
+    let x = a * Math.cos(t) * Math.cos(phi) - b * Math.sin(t) * Math.sin(phi);
+    const z = a * Math.cos(t) * Math.sin(phi) + b * Math.sin(t) * Math.cos(phi);
+    const y = (major + x) * Math.sin(u);
+    x = (major + x) * Math.cos(u);
+    target.set(x, y, z);
+  }
+};
+ParametricGeometries.TubeGeometry = class TubeGeometry extends ParametricGeometry {
+  constructor(path, segments = 64, radius = 1, segmentsRadius = 8, closed = false) {
+    const numpoints = segments + 1;
+    const frames = path.computeFrenetFrames(segments, closed), tangents = frames.tangents, normals = frames.normals, binormals = frames.binormals;
+    const position = new Vector3();
+    function ParametricTube(u, v, target) {
+      v *= 2 * Math.PI;
+      const i = Math.floor(u * (numpoints - 1));
+      path.getPointAt(u, position);
+      const normal = normals[i];
+      const binormal = binormals[i];
+      const cx = -radius * Math.cos(v);
+      const cy = radius * Math.sin(v);
+      position.x += cx * normal.x + cy * binormal.x;
+      position.y += cx * normal.y + cy * binormal.y;
+      position.z += cx * normal.z + cy * binormal.z;
+      target.copy(position);
+    }
+    super(ParametricTube, segments, segmentsRadius);
+    this.tangents = tangents;
+    this.normals = normals;
+    this.binormals = binormals;
+    this.path = path;
+    this.segments = segments;
+    this.radius = radius;
+    this.segmentsRadius = segmentsRadius;
+    this.closed = closed;
+  }
+};
+ParametricGeometries.TorusKnotGeometry = class TorusKnotGeometry extends ParametricGeometries.TubeGeometry {
+  constructor(radius = 200, tube = 40, segmentsT = 64, segmentsR = 8, p = 2, q = 3) {
+    class TorusKnotCurve extends Curve {
+      getPoint(t, optionalTarget = new Vector3()) {
+        const point = optionalTarget;
+        t *= Math.PI * 2;
+        const r = 0.5;
+        const x = (1 + r * Math.cos(q * t)) * Math.cos(p * t);
+        const y = (1 + r * Math.cos(q * t)) * Math.sin(p * t);
+        const z = r * Math.sin(q * t);
+        return point.set(x, y, z).multiplyScalar(radius);
+      }
+    }
+    const segments = segmentsT;
+    const radiusSegments = segmentsR;
+    const extrudePath = new TorusKnotCurve();
+    super(extrudePath, segments, tube, radiusSegments, true, false);
+    this.radius = radius;
+    this.tube = tube;
+    this.segmentsT = segmentsT;
+    this.segmentsR = segmentsR;
+    this.p = p;
+    this.q = q;
+  }
+};
+ParametricGeometries.SphereGeometry = class SphereGeometry extends ParametricGeometry {
+  constructor(size, u, v) {
+    function sphere(u2, v2, target) {
+      u2 *= Math.PI;
+      v2 *= 2 * Math.PI;
+      const x = size * Math.sin(u2) * Math.cos(v2);
+      const y = size * Math.sin(u2) * Math.sin(v2);
+      const z = size * Math.cos(u2);
+      target.set(x, y, z);
+    }
+    super(sphere, u, v);
+  }
+};
+ParametricGeometries.PlaneGeometry = class PlaneGeometry extends ParametricGeometry {
+  constructor(width, depth, segmentsWidth, segmentsDepth) {
+    function plane(u, v, target) {
+      const x = u * width;
+      const y = 0;
+      const z = v * depth;
+      target.set(x, y, z);
+    }
+    super(plane, segmentsWidth, segmentsDepth);
+  }
+};
+export {
+  ParametricGeometries
+};

package/dist/geometries/ParametricGeometry.d.ts

@@ -0,0 +1,18 @@
+import { Vector3, BufferGeometry } from 'three'
+
+export class ParametricGeometry extends BufferGeometry {
+  constructor(func?: (u: number, v: number, target: Vector3) => void, slices?: number, stacks?: number)
+
+  /**
+   * @default 'ParametricGeometry'
+   */
+  type: string
+
+  parameters: {
+    func: (u: number, v: number, dest: Vector3) => void
+    slices: number
+    stacks: number
+  }
+}
+
+export { ParametricGeometry as ParametricBufferGeometry }

package/dist/geometries/ParametricGeometry.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+class ParametricGeometry extends THREE.BufferGeometry {
+  constructor(func = (u, v, target) => target.set(u, v, Math.cos(u) * Math.sin(v)), slices = 8, stacks = 8) {
+    super();
+    this.type = "ParametricGeometry";
+    this.parameters = {
+      func,
+      slices,
+      stacks
+    };
+    const indices = [];
+    const vertices = [];
+    const normals = [];
+    const uvs = [];
+    const EPS = 1e-5;
+    const normal = new THREE.Vector3();
+    const p0 = new THREE.Vector3(), p1 = new THREE.Vector3();
+    const pu = new THREE.Vector3(), pv = new THREE.Vector3();
+    const sliceCount = slices + 1;
+    for (let i = 0; i <= stacks; i++) {
+      const v = i / stacks;
+      for (let j = 0; j <= slices; j++) {
+        const u = j / slices;
+        func(u, v, p0);
+        vertices.push(p0.x, p0.y, p0.z);
+        if (u - EPS >= 0) {
+          func(u - EPS, v, p1);
+          pu.subVectors(p0, p1);
+        } else {
+          func(u + EPS, v, p1);
+          pu.subVectors(p1, p0);
+        }
+        if (v - EPS >= 0) {
+          func(u, v - EPS, p1);
+          pv.subVectors(p0, p1);
+        } else {
+          func(u, v + EPS, p1);
+          pv.subVectors(p1, p0);
+        }
+        normal.crossVectors(pu, pv).normalize();
+        normals.push(normal.x, normal.y, normal.z);
+        uvs.push(u, v);
+      }
+    }
+    for (let i = 0; i < stacks; i++) {
+      for (let j = 0; j < slices; j++) {
+        const a = i * sliceCount + j;
+        const b = i * sliceCount + j + 1;
+        const c = (i + 1) * sliceCount + j + 1;
+        const d = (i + 1) * sliceCount + j;
+        indices.push(a, b, d);
+        indices.push(b, c, d);
+      }
+    }
+    this.setIndex(indices);
+    this.setAttribute("position", new THREE.Float32BufferAttribute(vertices, 3));
+    this.setAttribute("normal", new THREE.Float32BufferAttribute(normals, 3));
+    this.setAttribute("uv", new THREE.Float32BufferAttribute(uvs, 2));
+  }
+}
+exports.ParametricGeometry = ParametricGeometry;

package/dist/geometries/ParametricGeometry.mjs

@@ -0,0 +1,63 @@
+import { BufferGeometry, Vector3, Float32BufferAttribute } from "three";
+class ParametricGeometry extends BufferGeometry {
+  constructor(func = (u, v, target) => target.set(u, v, Math.cos(u) * Math.sin(v)), slices = 8, stacks = 8) {
+    super();
+    this.type = "ParametricGeometry";
+    this.parameters = {
+      func,
+      slices,
+      stacks
+    };
+    const indices = [];
+    const vertices = [];
+    const normals = [];
+    const uvs = [];
+    const EPS = 1e-5;
+    const normal = new Vector3();
+    const p0 = new Vector3(), p1 = new Vector3();
+    const pu = new Vector3(), pv = new Vector3();
+    const sliceCount = slices + 1;
+    for (let i = 0; i <= stacks; i++) {
+      const v = i / stacks;
+      for (let j = 0; j <= slices; j++) {
+        const u = j / slices;
+        func(u, v, p0);
+        vertices.push(p0.x, p0.y, p0.z);
+        if (u - EPS >= 0) {
+          func(u - EPS, v, p1);
+          pu.subVectors(p0, p1);
+        } else {
+          func(u + EPS, v, p1);
+          pu.subVectors(p1, p0);
+        }
+        if (v - EPS >= 0) {
+          func(u, v - EPS, p1);
+          pv.subVectors(p0, p1);
+        } else {
+          func(u, v + EPS, p1);
+          pv.subVectors(p1, p0);
+        }
+        normal.crossVectors(pu, pv).normalize();
+        normals.push(normal.x, normal.y, normal.z);
+        uvs.push(u, v);
+      }
+    }
+    for (let i = 0; i < stacks; i++) {
+      for (let j = 0; j < slices; j++) {
+        const a = i * sliceCount + j;
+        const b = i * sliceCount + j + 1;
+        const c = (i + 1) * sliceCount + j + 1;
+        const d = (i + 1) * sliceCount + j;
+        indices.push(a, b, d);
+        indices.push(b, c, d);
+      }
+    }
+    this.setIndex(indices);
+    this.setAttribute("position", new Float32BufferAttribute(vertices, 3));
+    this.setAttribute("normal", new Float32BufferAttribute(normals, 3));
+    this.setAttribute("uv", new Float32BufferAttribute(uvs, 2));
+  }
+}
+export {
+  ParametricGeometry
+};

package/dist/geometries/RoundedBoxGeometry.d.ts

@@ -0,0 +1,5 @@
+import { BoxGeometry } from 'three'
+
+export class RoundedBoxGeometry extends BoxGeometry {
+  constructor(width?: number, height?: number, depth?: number, segments?: number, radius?: number)
+}

package/dist/geometries/RoundedBoxGeometry.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const tempNormal = new THREE.Vector3();
+function getUv(faceDirVector, normal, uvAxis, projectionAxis, radius, sideLength) {
+  const totArcLength = 2 * Math.PI * radius / 4;
+  const centerLength = Math.max(sideLength - 2 * radius, 0);
+  const halfArc = Math.PI / 4;
+  tempNormal.copy(normal);
+  tempNormal[projectionAxis] = 0;
+  tempNormal.normalize();
+  const arcUvRatio = 0.5 * totArcLength / (totArcLength + centerLength);
+  const arcAngleRatio = 1 - tempNormal.angleTo(faceDirVector) / halfArc;
+  if (Math.sign(tempNormal[uvAxis]) === 1) {
+    return arcAngleRatio * arcUvRatio;
+  } else {
+    const lenUv = centerLength / (totArcLength + centerLength);
+    return lenUv + arcUvRatio + arcUvRatio * (1 - arcAngleRatio);
+  }
+}
+class RoundedBoxGeometry extends THREE.BoxGeometry {
+  constructor(width = 1, height = 1, depth = 1, segments = 2, radius = 0.1) {
+    segments = segments * 2 + 1;
+    radius = Math.min(width / 2, height / 2, depth / 2, radius);
+    super(1, 1, 1, segments, segments, segments);
+    if (segments === 1)
+      return;
+    const geometry2 = this.toNonIndexed();
+    this.index = null;
+    this.attributes.position = geometry2.attributes.position;
+    this.attributes.normal = geometry2.attributes.normal;
+    this.attributes.uv = geometry2.attributes.uv;
+    const position = new THREE.Vector3();
+    const normal = new THREE.Vector3();
+    const box = new THREE.Vector3(width, height, depth).divideScalar(2).subScalar(radius);
+    const positions = this.attributes.position.array;
+    const normals = this.attributes.normal.array;
+    const uvs = this.attributes.uv.array;
+    const faceTris = positions.length / 6;
+    const faceDirVector = new THREE.Vector3();
+    const halfSegmentSize = 0.5 / segments;
+    for (let i = 0, j = 0; i < positions.length; i += 3, j += 2) {
+      position.fromArray(positions, i);
+      normal.copy(position);
+      normal.x -= Math.sign(normal.x) * halfSegmentSize;
+      normal.y -= Math.sign(normal.y) * halfSegmentSize;
+      normal.z -= Math.sign(normal.z) * halfSegmentSize;
+      normal.normalize();
+      positions[i + 0] = box.x * Math.sign(position.x) + normal.x * radius;
+      positions[i + 1] = box.y * Math.sign(position.y) + normal.y * radius;
+      positions[i + 2] = box.z * Math.sign(position.z) + normal.z * radius;
+      normals[i + 0] = normal.x;
+      normals[i + 1] = normal.y;
+      normals[i + 2] = normal.z;
+      const side = Math.floor(i / faceTris);
+      switch (side) {
+        case 0:
+          faceDirVector.set(1, 0, 0);
+          uvs[j + 0] = getUv(faceDirVector, normal, "z", "y", radius, depth);
+          uvs[j + 1] = 1 - getUv(faceDirVector, normal, "y", "z", radius, height);
+          break;
+        case 1:
+          faceDirVector.set(-1, 0, 0);
+          uvs[j + 0] = 1 - getUv(faceDirVector, normal, "z", "y", radius, depth);
+          uvs[j + 1] = 1 - getUv(faceDirVector, normal, "y", "z", radius, height);
+          break;
+        case 2:
+          faceDirVector.set(0, 1, 0);
+          uvs[j + 0] = 1 - getUv(faceDirVector, normal, "x", "z", radius, width);
+          uvs[j + 1] = getUv(faceDirVector, normal, "z", "x", radius, depth);
+          break;
+        case 3:
+          faceDirVector.set(0, -1, 0);
+          uvs[j + 0] = 1 - getUv(faceDirVector, normal, "x", "z", radius, width);
+          uvs[j + 1] = 1 - getUv(faceDirVector, normal, "z", "x", radius, depth);
+          break;
+        case 4:
+          faceDirVector.set(0, 0, 1);
+          uvs[j + 0] = 1 - getUv(faceDirVector, normal, "x", "y", radius, width);
+          uvs[j + 1] = 1 - getUv(faceDirVector, normal, "y", "x", radius, height);
+          break;
+        case 5:
+          faceDirVector.set(0, 0, -1);
+          uvs[j + 0] = getUv(faceDirVector, normal, "x", "y", radius, width);
+          uvs[j + 1] = 1 - getUv(faceDirVector, normal, "y", "x", radius, height);
+          break;
+      }
+    }
+  }
+}
+exports.RoundedBoxGeometry = RoundedBoxGeometry;

package/dist/geometries/RoundedBoxGeometry.mjs

@@ -0,0 +1,91 @@
+import { Vector3, BoxGeometry } from "three";
+const tempNormal = new Vector3();
+function getUv(faceDirVector, normal, uvAxis, projectionAxis, radius, sideLength) {
+  const totArcLength = 2 * Math.PI * radius / 4;
+  const centerLength = Math.max(sideLength - 2 * radius, 0);
+  const halfArc = Math.PI / 4;
+  tempNormal.copy(normal);
+  tempNormal[projectionAxis] = 0;
+  tempNormal.normalize();
+  const arcUvRatio = 0.5 * totArcLength / (totArcLength + centerLength);
+  const arcAngleRatio = 1 - tempNormal.angleTo(faceDirVector) / halfArc;
+  if (Math.sign(tempNormal[uvAxis]) === 1) {
+    return arcAngleRatio * arcUvRatio;
+  } else {
+    const lenUv = centerLength / (totArcLength + centerLength);
+    return lenUv + arcUvRatio + arcUvRatio * (1 - arcAngleRatio);
+  }
+}
+class RoundedBoxGeometry extends BoxGeometry {
+  constructor(width = 1, height = 1, depth = 1, segments = 2, radius = 0.1) {
+    segments = segments * 2 + 1;
+    radius = Math.min(width / 2, height / 2, depth / 2, radius);
+    super(1, 1, 1, segments, segments, segments);
+    if (segments === 1)
+      return;
+    const geometry2 = this.toNonIndexed();
+    this.index = null;
+    this.attributes.position = geometry2.attributes.position;
+    this.attributes.normal = geometry2.attributes.normal;
+    this.attributes.uv = geometry2.attributes.uv;
+    const position = new Vector3();
+    const normal = new Vector3();
+    const box = new Vector3(width, height, depth).divideScalar(2).subScalar(radius);
+    const positions = this.attributes.position.array;
+    const normals = this.attributes.normal.array;
+    const uvs = this.attributes.uv.array;
+    const faceTris = positions.length / 6;
+    const faceDirVector = new Vector3();
+    const halfSegmentSize = 0.5 / segments;
+    for (let i = 0, j = 0; i < positions.length; i += 3, j += 2) {
+      position.fromArray(positions, i);
+      normal.copy(position);
+      normal.x -= Math.sign(normal.x) * halfSegmentSize;
+      normal.y -= Math.sign(normal.y) * halfSegmentSize;
+      normal.z -= Math.sign(normal.z) * halfSegmentSize;
+      normal.normalize();
+      positions[i + 0] = box.x * Math.sign(position.x) + normal.x * radius;
+      positions[i + 1] = box.y * Math.sign(position.y) + normal.y * radius;
+      positions[i + 2] = box.z * Math.sign(position.z) + normal.z * radius;
+      normals[i + 0] = normal.x;
+      normals[i + 1] = normal.y;
+      normals[i + 2] = normal.z;
+      const side = Math.floor(i / faceTris);
+      switch (side) {
+        case 0:
+          faceDirVector.set(1, 0, 0);
+          uvs[j + 0] = getUv(faceDirVector, normal, "z", "y", radius, depth);
+          uvs[j + 1] = 1 - getUv(faceDirVector, normal, "y", "z", radius, height);
+          break;
+        case 1:
+          faceDirVector.set(-1, 0, 0);
+          uvs[j + 0] = 1 - getUv(faceDirVector, normal, "z", "y", radius, depth);
+          uvs[j + 1] = 1 - getUv(faceDirVector, normal, "y", "z", radius, height);
+          break;
+        case 2:
+          faceDirVector.set(0, 1, 0);
+          uvs[j + 0] = 1 - getUv(faceDirVector, normal, "x", "z", radius, width);
+          uvs[j + 1] = getUv(faceDirVector, normal, "z", "x", radius, depth);
+          break;
+        case 3:
+          faceDirVector.set(0, -1, 0);
+          uvs[j + 0] = 1 - getUv(faceDirVector, normal, "x", "z", radius, width);
+          uvs[j + 1] = 1 - getUv(faceDirVector, normal, "z", "x", radius, depth);
+          break;
+        case 4:
+          faceDirVector.set(0, 0, 1);
+          uvs[j + 0] = 1 - getUv(faceDirVector, normal, "x", "y", radius, width);
+          uvs[j + 1] = 1 - getUv(faceDirVector, normal, "y", "x", radius, height);
+          break;
+        case 5:
+          faceDirVector.set(0, 0, -1);
+          uvs[j + 0] = getUv(faceDirVector, normal, "x", "y", radius, width);
+          uvs[j + 1] = 1 - getUv(faceDirVector, normal, "y", "x", radius, height);
+          break;
+      }
+    }
+  }
+}
+export {
+  RoundedBoxGeometry
+};

package/dist/geometries/TeapotGeometry.d.ts

@@ -0,0 +1,13 @@
+import { BufferGeometry } from 'three'
+
+export class TeapotGeometry extends BufferGeometry {
+  constructor(
+    size?: number,
+    segments?: number,
+    bottom?: boolean,
+    lid?: boolean,
+    body?: boolean,
+    fitLid?: boolean,
+    blinn?: number,
+  )
+}