three-stdlib 2.22.7 → 2.22.9

package/dist/geometries/TextGeometry.d.ts

@@ -0,0 +1,18 @@
+import { ExtrudeGeometry } from 'three';
+import type { Font } from '../loaders/FontLoader';
+export declare type TextGeometryParameters = {
+    bevelEnabled?: boolean;
+    bevelOffset?: number;
+    bevelSize?: number;
+    bevelThickness?: number;
+    curveSegments?: number;
+    font: Font;
+    height?: number;
+    size?: number;
+    lineHeight?: number;
+    letterSpacing?: number;
+};
+export declare class TextGeometry extends ExtrudeGeometry {
+    constructor(text: string, parameters?: TextGeometryParameters);
+}
+export { TextGeometry as TextBufferGeometry };

package/dist/geometries/TextGeometry.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+class TextGeometry extends THREE.ExtrudeGeometry {
+  constructor(text, parameters = {}) {
+    const {
+      bevelEnabled = false,
+      bevelSize = 8,
+      bevelThickness = 10,
+      font,
+      height = 50,
+      size = 100,
+      lineHeight = 1,
+      letterSpacing = 0,
+      ...rest
+    } = parameters;
+    if (font === void 0) {
+      super();
+    } else {
+      const shapes = font.generateShapes(text, size, { lineHeight, letterSpacing });
+      super(shapes, { ...rest, bevelEnabled, bevelSize, bevelThickness, depth: height });
+    }
+    this.type = "TextGeometry";
+  }
+}
+exports.TextBufferGeometry = TextGeometry;
+exports.TextGeometry = TextGeometry;

package/dist/geometries/TextGeometry.mjs

@@ -0,0 +1,27 @@
+import { ExtrudeGeometry } from "three";
+class TextGeometry extends ExtrudeGeometry {
+  constructor(text, parameters = {}) {
+    const {
+      bevelEnabled = false,
+      bevelSize = 8,
+      bevelThickness = 10,
+      font,
+      height = 50,
+      size = 100,
+      lineHeight = 1,
+      letterSpacing = 0,
+      ...rest
+    } = parameters;
+    if (font === void 0) {
+      super();
+    } else {
+      const shapes = font.generateShapes(text, size, { lineHeight, letterSpacing });
+      super(shapes, { ...rest, bevelEnabled, bevelSize, bevelThickness, depth: height });
+    }
+    this.type = "TextGeometry";
+  }
+}
+export {
+  TextGeometry as TextBufferGeometry,
+  TextGeometry
+};

package/dist/helpers/LightProbeHelper.d.ts

@@ -0,0 +1,10 @@
+import { LightProbe, Mesh } from 'three'
+
+export class LightProbeHelper extends Mesh {
+  constructor(lightProbe: LightProbe, size: number)
+
+  lightProbe: LightProbe
+  size: number
+
+  dispose(): void
+}

package/dist/helpers/LightProbeHelper.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+class LightProbeHelper extends THREE.Mesh {
+  constructor(lightProbe, size) {
+    const material = new THREE.ShaderMaterial({
+      type: "LightProbeHelperMaterial",
+      uniforms: {
+        sh: { value: lightProbe.sh.coefficients },
+        // by reference
+        intensity: { value: lightProbe.intensity }
+      },
+      vertexShader: [
+        "varying vec3 vNormal;",
+        "void main() {",
+        "	vNormal = normalize( normalMatrix * normal );",
+        "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+        "}"
+      ].join("\n"),
+      fragmentShader: [
+        "#define RECIPROCAL_PI 0.318309886",
+        "vec3 inverseTransformDirection( in vec3 normal, in mat4 matrix ) {",
+        "	// matrix is assumed to be orthogonal",
+        "	return normalize( ( vec4( normal, 0.0 ) * matrix ).xyz );",
+        "}",
+        "// source: https://graphics.stanford.edu/papers/envmap/envmap.pdf",
+        "vec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {",
+        "	// normal is assumed to have unit length",
+        "	float x = normal.x, y = normal.y, z = normal.z;",
+        "	// band 0",
+        "	vec3 result = shCoefficients[ 0 ] * 0.886227;",
+        "	// band 1",
+        "	result += shCoefficients[ 1 ] * 2.0 * 0.511664 * y;",
+        "	result += shCoefficients[ 2 ] * 2.0 * 0.511664 * z;",
+        "	result += shCoefficients[ 3 ] * 2.0 * 0.511664 * x;",
+        "	// band 2",
+        "	result += shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;",
+        "	result += shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;",
+        "	result += shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );",
+        "	result += shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;",
+        "	result += shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );",
+        "	return result;",
+        "}",
+        "uniform vec3 sh[ 9 ]; // sh coefficients",
+        "uniform float intensity; // light probe intensity",
+        "varying vec3 vNormal;",
+        "void main() {",
+        "	vec3 normal = normalize( vNormal );",
+        "	vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );",
+        "	vec3 irradiance = shGetIrradianceAt( worldNormal, sh );",
+        "	vec3 outgoingLight = RECIPROCAL_PI * irradiance * intensity;",
+        "	gl_FragColor = linearToOutputTexel( vec4( outgoingLight, 1.0 ) );",
+        "}"
+      ].join("\n")
+    });
+    const geometry = new THREE.SphereGeometry(1, 32, 16);
+    super(geometry, material);
+    this.lightProbe = lightProbe;
+    this.size = size;
+    this.type = "LightProbeHelper";
+    this.onBeforeRender();
+  }
+  dispose() {
+    this.geometry.dispose();
+    this.material.dispose();
+  }
+  onBeforeRender() {
+    this.position.copy(this.lightProbe.position);
+    this.scale.set(1, 1, 1).multiplyScalar(this.size);
+    this.material.uniforms.intensity.value = this.lightProbe.intensity;
+  }
+}
+exports.LightProbeHelper = LightProbeHelper;

package/dist/helpers/LightProbeHelper.mjs

@@ -0,0 +1,73 @@
+import { Mesh, ShaderMaterial, SphereGeometry } from "three";
+class LightProbeHelper extends Mesh {
+  constructor(lightProbe, size) {
+    const material = new ShaderMaterial({
+      type: "LightProbeHelperMaterial",
+      uniforms: {
+        sh: { value: lightProbe.sh.coefficients },
+        // by reference
+        intensity: { value: lightProbe.intensity }
+      },
+      vertexShader: [
+        "varying vec3 vNormal;",
+        "void main() {",
+        "	vNormal = normalize( normalMatrix * normal );",
+        "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+        "}"
+      ].join("\n"),
+      fragmentShader: [
+        "#define RECIPROCAL_PI 0.318309886",
+        "vec3 inverseTransformDirection( in vec3 normal, in mat4 matrix ) {",
+        "	// matrix is assumed to be orthogonal",
+        "	return normalize( ( vec4( normal, 0.0 ) * matrix ).xyz );",
+        "}",
+        "// source: https://graphics.stanford.edu/papers/envmap/envmap.pdf",
+        "vec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {",
+        "	// normal is assumed to have unit length",
+        "	float x = normal.x, y = normal.y, z = normal.z;",
+        "	// band 0",
+        "	vec3 result = shCoefficients[ 0 ] * 0.886227;",
+        "	// band 1",
+        "	result += shCoefficients[ 1 ] * 2.0 * 0.511664 * y;",
+        "	result += shCoefficients[ 2 ] * 2.0 * 0.511664 * z;",
+        "	result += shCoefficients[ 3 ] * 2.0 * 0.511664 * x;",
+        "	// band 2",
+        "	result += shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;",
+        "	result += shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;",
+        "	result += shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );",
+        "	result += shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;",
+        "	result += shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );",
+        "	return result;",
+        "}",
+        "uniform vec3 sh[ 9 ]; // sh coefficients",
+        "uniform float intensity; // light probe intensity",
+        "varying vec3 vNormal;",
+        "void main() {",
+        "	vec3 normal = normalize( vNormal );",
+        "	vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );",
+        "	vec3 irradiance = shGetIrradianceAt( worldNormal, sh );",
+        "	vec3 outgoingLight = RECIPROCAL_PI * irradiance * intensity;",
+        "	gl_FragColor = linearToOutputTexel( vec4( outgoingLight, 1.0 ) );",
+        "}"
+      ].join("\n")
+    });
+    const geometry = new SphereGeometry(1, 32, 16);
+    super(geometry, material);
+    this.lightProbe = lightProbe;
+    this.size = size;
+    this.type = "LightProbeHelper";
+    this.onBeforeRender();
+  }
+  dispose() {
+    this.geometry.dispose();
+    this.material.dispose();
+  }
+  onBeforeRender() {
+    this.position.copy(this.lightProbe.position);
+    this.scale.set(1, 1, 1).multiplyScalar(this.size);
+    this.material.uniforms.intensity.value = this.lightProbe.intensity;
+  }
+}
+export {
+  LightProbeHelper
+};

package/dist/helpers/PositionalAudioHelper.d.ts

@@ -0,0 +1,13 @@
+import { Line, PositionalAudio } from 'three'
+
+export class PositionalAudioHelper extends Line {
+  constructor(audio: PositionalAudio, range?: number, divisionsInnerAngle?: number, divisionsOuterAngle?: number)
+
+  audio: PositionalAudio
+  range: number
+  divisionsInnerAngle: number
+  divisionsOuterAngle: number
+
+  dispose(): void
+  update(): void
+}

package/dist/helpers/PositionalAudioHelper.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+class PositionalAudioHelper extends THREE.Line {
+  constructor(audio, range = 1, divisionsInnerAngle = 16, divisionsOuterAngle = 2) {
+    const geometry = new THREE.BufferGeometry();
+    const divisions = divisionsInnerAngle + divisionsOuterAngle * 2;
+    const positions = new Float32Array((divisions * 3 + 3) * 3);
+    geometry.setAttribute("position", new THREE.BufferAttribute(positions, 3));
+    const materialInnerAngle = new THREE.LineBasicMaterial({ color: 65280 });
+    const materialOuterAngle = new THREE.LineBasicMaterial({ color: 16776960 });
+    super(geometry, [materialOuterAngle, materialInnerAngle]);
+    this.type = "PositionalAudioHelper";
+    this.audio = audio;
+    this.range = range;
+    this.divisionsInnerAngle = divisionsInnerAngle;
+    this.divisionsOuterAngle = divisionsOuterAngle;
+    this.update();
+  }
+  update() {
+    const audio = this.audio;
+    const range = this.range;
+    const divisionsInnerAngle = this.divisionsInnerAngle;
+    const divisionsOuterAngle = this.divisionsOuterAngle;
+    const coneInnerAngle = THREE.MathUtils.degToRad(audio.panner.coneInnerAngle);
+    const coneOuterAngle = THREE.MathUtils.degToRad(audio.panner.coneOuterAngle);
+    const halfConeInnerAngle = coneInnerAngle / 2;
+    const halfConeOuterAngle = coneOuterAngle / 2;
+    let start = 0;
+    let count = 0;
+    let i, stride;
+    const geometry = this.geometry;
+    const positionAttribute = geometry.attributes.position;
+    geometry.clearGroups();
+    function generateSegment(from, to, divisions, materialIndex) {
+      const step = (to - from) / divisions;
+      positionAttribute.setXYZ(start, 0, 0, 0);
+      count++;
+      for (i = from; i < to; i += step) {
+        stride = start + count;
+        positionAttribute.setXYZ(stride, Math.sin(i) * range, 0, Math.cos(i) * range);
+        positionAttribute.setXYZ(
+          stride + 1,
+          Math.sin(Math.min(i + step, to)) * range,
+          0,
+          Math.cos(Math.min(i + step, to)) * range
+        );
+        positionAttribute.setXYZ(stride + 2, 0, 0, 0);
+        count += 3;
+      }
+      geometry.addGroup(start, count, materialIndex);
+      start += count;
+      count = 0;
+    }
+    generateSegment(-halfConeOuterAngle, -halfConeInnerAngle, divisionsOuterAngle, 0);
+    generateSegment(-halfConeInnerAngle, halfConeInnerAngle, divisionsInnerAngle, 1);
+    generateSegment(halfConeInnerAngle, halfConeOuterAngle, divisionsOuterAngle, 0);
+    positionAttribute.needsUpdate = true;
+    if (coneInnerAngle === coneOuterAngle)
+      this.material[0].visible = false;
+  }
+  dispose() {
+    this.geometry.dispose();
+    this.material[0].dispose();
+    this.material[1].dispose();
+  }
+}
+exports.PositionalAudioHelper = PositionalAudioHelper;

package/dist/helpers/PositionalAudioHelper.mjs

@@ -0,0 +1,68 @@
+import { Line, BufferGeometry, BufferAttribute, LineBasicMaterial, MathUtils } from "three";
+class PositionalAudioHelper extends Line {
+  constructor(audio, range = 1, divisionsInnerAngle = 16, divisionsOuterAngle = 2) {
+    const geometry = new BufferGeometry();
+    const divisions = divisionsInnerAngle + divisionsOuterAngle * 2;
+    const positions = new Float32Array((divisions * 3 + 3) * 3);
+    geometry.setAttribute("position", new BufferAttribute(positions, 3));
+    const materialInnerAngle = new LineBasicMaterial({ color: 65280 });
+    const materialOuterAngle = new LineBasicMaterial({ color: 16776960 });
+    super(geometry, [materialOuterAngle, materialInnerAngle]);
+    this.type = "PositionalAudioHelper";
+    this.audio = audio;
+    this.range = range;
+    this.divisionsInnerAngle = divisionsInnerAngle;
+    this.divisionsOuterAngle = divisionsOuterAngle;
+    this.update();
+  }
+  update() {
+    const audio = this.audio;
+    const range = this.range;
+    const divisionsInnerAngle = this.divisionsInnerAngle;
+    const divisionsOuterAngle = this.divisionsOuterAngle;
+    const coneInnerAngle = MathUtils.degToRad(audio.panner.coneInnerAngle);
+    const coneOuterAngle = MathUtils.degToRad(audio.panner.coneOuterAngle);
+    const halfConeInnerAngle = coneInnerAngle / 2;
+    const halfConeOuterAngle = coneOuterAngle / 2;
+    let start = 0;
+    let count = 0;
+    let i, stride;
+    const geometry = this.geometry;
+    const positionAttribute = geometry.attributes.position;
+    geometry.clearGroups();
+    function generateSegment(from, to, divisions, materialIndex) {
+      const step = (to - from) / divisions;
+      positionAttribute.setXYZ(start, 0, 0, 0);
+      count++;
+      for (i = from; i < to; i += step) {
+        stride = start + count;
+        positionAttribute.setXYZ(stride, Math.sin(i) * range, 0, Math.cos(i) * range);
+        positionAttribute.setXYZ(
+          stride + 1,
+          Math.sin(Math.min(i + step, to)) * range,
+          0,
+          Math.cos(Math.min(i + step, to)) * range
+        );
+        positionAttribute.setXYZ(stride + 2, 0, 0, 0);
+        count += 3;
+      }
+      geometry.addGroup(start, count, materialIndex);
+      start += count;
+      count = 0;
+    }
+    generateSegment(-halfConeOuterAngle, -halfConeInnerAngle, divisionsOuterAngle, 0);
+    generateSegment(-halfConeInnerAngle, halfConeInnerAngle, divisionsInnerAngle, 1);
+    generateSegment(halfConeInnerAngle, halfConeOuterAngle, divisionsOuterAngle, 0);
+    positionAttribute.needsUpdate = true;
+    if (coneInnerAngle === coneOuterAngle)
+      this.material[0].visible = false;
+  }
+  dispose() {
+    this.geometry.dispose();
+    this.material[0].dispose();
+    this.material[1].dispose();
+  }
+}
+export {
+  PositionalAudioHelper
+};

package/dist/helpers/RectAreaLightHelper.d.ts

@@ -0,0 +1,10 @@
+import { Line, RectAreaLight, ColorRepresentation } from 'three'
+
+export class RectAreaLightHelper extends Line {
+  constructor(light: RectAreaLight, color?: ColorRepresentation)
+
+  light: RectAreaLight
+  color: ColorRepresentation | undefined
+
+  dispose(): void
+}

package/dist/helpers/RectAreaLightHelper.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+class RectAreaLightHelper extends THREE.Line {
+  constructor(light, color) {
+    const positions = [1, 1, 0, -1, 1, 0, -1, -1, 0, 1, -1, 0, 1, 1, 0];
+    const geometry = new THREE.BufferGeometry();
+    geometry.setAttribute("position", new THREE.Float32BufferAttribute(positions, 3));
+    geometry.computeBoundingSphere();
+    const material = new THREE.LineBasicMaterial({ fog: false });
+    super(geometry, material);
+    this.type = "RectAreaLightHelper";
+    this.light = light;
+    this.color = color;
+    const positions2 = [1, 1, 0, -1, 1, 0, -1, -1, 0, 1, 1, 0, -1, -1, 0, 1, -1, 0];
+    const geometry2 = new THREE.BufferGeometry();
+    geometry2.setAttribute("position", new THREE.Float32BufferAttribute(positions2, 3));
+    geometry2.computeBoundingSphere();
+    this.add(new THREE.Mesh(geometry2, new THREE.MeshBasicMaterial({ side: THREE.BackSide, fog: false })));
+  }
+  updateMatrixWorld() {
+    this.scale.set(0.5 * this.light.width, 0.5 * this.light.height, 1);
+    if (this.color !== void 0) {
+      this.material.color.set(this.color);
+      this.children[0].material.color.set(this.color);
+    } else {
+      this.material.color.copy(this.light.color).multiplyScalar(this.light.intensity);
+      const c = this.material.color;
+      const max = Math.max(c.r, c.g, c.b);
+      if (max > 1)
+        c.multiplyScalar(1 / max);
+      this.children[0].material.color.copy(this.material.color);
+    }
+    this.matrixWorld.copy(this.light.matrixWorld).scale(this.scale);
+    this.children[0].matrixWorld.copy(this.matrixWorld);
+  }
+  dispose() {
+    this.geometry.dispose();
+    this.material.dispose();
+    this.children[0].geometry.dispose();
+    this.children[0].material.dispose();
+  }
+}
+exports.RectAreaLightHelper = RectAreaLightHelper;

package/dist/helpers/RectAreaLightHelper.mjs

@@ -0,0 +1,44 @@
+import { Line, BufferGeometry, Float32BufferAttribute, LineBasicMaterial, Mesh, MeshBasicMaterial, BackSide } from "three";
+class RectAreaLightHelper extends Line {
+  constructor(light, color) {
+    const positions = [1, 1, 0, -1, 1, 0, -1, -1, 0, 1, -1, 0, 1, 1, 0];
+    const geometry = new BufferGeometry();
+    geometry.setAttribute("position", new Float32BufferAttribute(positions, 3));
+    geometry.computeBoundingSphere();
+    const material = new LineBasicMaterial({ fog: false });
+    super(geometry, material);
+    this.type = "RectAreaLightHelper";
+    this.light = light;
+    this.color = color;
+    const positions2 = [1, 1, 0, -1, 1, 0, -1, -1, 0, 1, 1, 0, -1, -1, 0, 1, -1, 0];
+    const geometry2 = new BufferGeometry();
+    geometry2.setAttribute("position", new Float32BufferAttribute(positions2, 3));
+    geometry2.computeBoundingSphere();
+    this.add(new Mesh(geometry2, new MeshBasicMaterial({ side: BackSide, fog: false })));
+  }
+  updateMatrixWorld() {
+    this.scale.set(0.5 * this.light.width, 0.5 * this.light.height, 1);
+    if (this.color !== void 0) {
+      this.material.color.set(this.color);
+      this.children[0].material.color.set(this.color);
+    } else {
+      this.material.color.copy(this.light.color).multiplyScalar(this.light.intensity);
+      const c = this.material.color;
+      const max = Math.max(c.r, c.g, c.b);
+      if (max > 1)
+        c.multiplyScalar(1 / max);
+      this.children[0].material.color.copy(this.material.color);
+    }
+    this.matrixWorld.copy(this.light.matrixWorld).scale(this.scale);
+    this.children[0].matrixWorld.copy(this.matrixWorld);
+  }
+  dispose() {
+    this.geometry.dispose();
+    this.material.dispose();
+    this.children[0].geometry.dispose();
+    this.children[0].material.dispose();
+  }
+}
+export {
+  RectAreaLightHelper
+};

package/dist/helpers/VertexNormalsHelper.d.ts

@@ -0,0 +1,10 @@
+import { Object3D, LineSegments } from 'three'
+
+export class VertexNormalsHelper extends LineSegments {
+  constructor(object: Object3D, size?: number, hex?: number)
+
+  object: Object3D
+  size: number
+
+  update(): void
+}

package/dist/helpers/VertexNormalsHelper.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const _v1 = new THREE.Vector3();
+const _v2 = new THREE.Vector3();
+const _normalMatrix = new THREE.Matrix3();
+class VertexNormalsHelper extends THREE.LineSegments {
+  constructor(object, size, hex) {
+    const geometry = new THREE.BufferGeometry();
+    const color = hex !== void 0 ? hex : 16711680;
+    super(geometry, new THREE.LineBasicMaterial({ color, toneMapped: false }));
+    this.object = object;
+    this.size = size !== void 0 ? size : 0.1;
+    let nNormals = 0;
+    const objGeometry = this.object.geometry;
+    if (objGeometry && objGeometry.isGeometry) {
+      console.error("THREE.VertexNormalsHelper no longer supports Geometry. Use BufferGeometry instead.");
+      return;
+    } else if (objGeometry && objGeometry.isBufferGeometry) {
+      nNormals = objGeometry.attributes.normal.count;
+    }
+    const positions = new THREE.Float32BufferAttribute(nNormals * 2 * 3, 3);
+    geometry.setAttribute("position", positions);
+    this.type = "VertexNormalsHelper";
+    this.matrixAutoUpdate = false;
+    this.update();
+  }
+  update() {
+    this.object.updateMatrixWorld(true);
+    _normalMatrix.getNormalMatrix(this.object.matrixWorld);
+    const matrixWorld = this.object.matrixWorld;
+    const position = this.geometry.attributes.position;
+    const objGeometry = this.object.geometry;
+    if (objGeometry && objGeometry.isGeometry) {
+      console.error("THREE.VertexNormalsHelper no longer supports Geometry. Use BufferGeometry instead.");
+      return;
+    } else if (objGeometry && objGeometry.isBufferGeometry) {
+      const objPos = objGeometry.attributes.position;
+      const objNorm = objGeometry.attributes.normal;
+      let idx = 0;
+      for (let j = 0, jl = objPos.count; j < jl; j++) {
+        _v1.set(objPos.getX(j), objPos.getY(j), objPos.getZ(j)).applyMatrix4(matrixWorld);
+        _v2.set(objNorm.getX(j), objNorm.getY(j), objNorm.getZ(j));
+        _v2.applyMatrix3(_normalMatrix).normalize().multiplyScalar(this.size).add(_v1);
+        position.setXYZ(idx, _v1.x, _v1.y, _v1.z);
+        idx = idx + 1;
+        position.setXYZ(idx, _v2.x, _v2.y, _v2.z);
+        idx = idx + 1;
+      }
+    }
+    position.needsUpdate = true;
+  }
+}
+exports.VertexNormalsHelper = VertexNormalsHelper;

package/dist/helpers/VertexNormalsHelper.mjs

@@ -0,0 +1,54 @@
+import { Vector3, Matrix3, LineSegments, BufferGeometry, LineBasicMaterial, Float32BufferAttribute } from "three";
+const _v1 = new Vector3();
+const _v2 = new Vector3();
+const _normalMatrix = new Matrix3();
+class VertexNormalsHelper extends LineSegments {
+  constructor(object, size, hex) {
+    const geometry = new BufferGeometry();
+    const color = hex !== void 0 ? hex : 16711680;
+    super(geometry, new LineBasicMaterial({ color, toneMapped: false }));
+    this.object = object;
+    this.size = size !== void 0 ? size : 0.1;
+    let nNormals = 0;
+    const objGeometry = this.object.geometry;
+    if (objGeometry && objGeometry.isGeometry) {
+      console.error("THREE.VertexNormalsHelper no longer supports Geometry. Use BufferGeometry instead.");
+      return;
+    } else if (objGeometry && objGeometry.isBufferGeometry) {
+      nNormals = objGeometry.attributes.normal.count;
+    }
+    const positions = new Float32BufferAttribute(nNormals * 2 * 3, 3);
+    geometry.setAttribute("position", positions);
+    this.type = "VertexNormalsHelper";
+    this.matrixAutoUpdate = false;
+    this.update();
+  }
+  update() {
+    this.object.updateMatrixWorld(true);
+    _normalMatrix.getNormalMatrix(this.object.matrixWorld);
+    const matrixWorld = this.object.matrixWorld;
+    const position = this.geometry.attributes.position;
+    const objGeometry = this.object.geometry;
+    if (objGeometry && objGeometry.isGeometry) {
+      console.error("THREE.VertexNormalsHelper no longer supports Geometry. Use BufferGeometry instead.");
+      return;
+    } else if (objGeometry && objGeometry.isBufferGeometry) {
+      const objPos = objGeometry.attributes.position;
+      const objNorm = objGeometry.attributes.normal;
+      let idx = 0;
+      for (let j = 0, jl = objPos.count; j < jl; j++) {
+        _v1.set(objPos.getX(j), objPos.getY(j), objPos.getZ(j)).applyMatrix4(matrixWorld);
+        _v2.set(objNorm.getX(j), objNorm.getY(j), objNorm.getZ(j));
+        _v2.applyMatrix3(_normalMatrix).normalize().multiplyScalar(this.size).add(_v1);
+        position.setXYZ(idx, _v1.x, _v1.y, _v1.z);
+        idx = idx + 1;
+        position.setXYZ(idx, _v2.x, _v2.y, _v2.z);
+        idx = idx + 1;
+      }
+    }
+    position.needsUpdate = true;
+  }
+}
+export {
+  VertexNormalsHelper
+};

package/dist/helpers/VertexTangentsHelper.d.ts

@@ -0,0 +1,10 @@
+import { Object3D, LineSegments } from 'three'
+
+export class VertexTangentsHelper extends LineSegments {
+  constructor(object: Object3D, size?: number, hex?: number)
+
+  object: Object3D
+  size: number
+
+  update(): void
+}

package/dist/helpers/VertexTangentsHelper.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const _v1 = new THREE.Vector3();
+const _v2 = new THREE.Vector3();
+class VertexTangentsHelper extends THREE.LineSegments {
+  constructor(object, size, hex) {
+    const color = hex !== void 0 ? hex : 65535;
+    const objGeometry = object.geometry;
+    if (!(objGeometry && objGeometry.isBufferGeometry)) {
+      console.error("THREE.VertexTangentsHelper: geometry not an instance of THREE.BufferGeometry.", objGeometry);
+      return;
+    }
+    const nTangents = objGeometry.attributes.tangent.count;
+    const geometry = new THREE.BufferGeometry();
+    const positions = new THREE.Float32BufferAttribute(nTangents * 2 * 3, 3);
+    geometry.setAttribute("position", positions);
+    super(geometry, new THREE.LineBasicMaterial({ color, toneMapped: false }));
+    this.type = "VertexTangentsHelper";
+    this.object = object;
+    this.size = size !== void 0 ? size : 1;
+    this.matrixAutoUpdate = false;
+    this.update();
+  }
+  update() {
+    this.object.updateMatrixWorld(true);
+    const matrixWorld = this.object.matrixWorld;
+    const position = this.geometry.attributes.position;
+    const objGeometry = this.object.geometry;
+    const objPos = objGeometry.attributes.position;
+    const objTan = objGeometry.attributes.tangent;
+    let idx = 0;
+    for (let j = 0, jl = objPos.count; j < jl; j++) {
+      _v1.set(objPos.getX(j), objPos.getY(j), objPos.getZ(j)).applyMatrix4(matrixWorld);
+      _v2.set(objTan.getX(j), objTan.getY(j), objTan.getZ(j));
+      _v2.transformDirection(matrixWorld).multiplyScalar(this.size).add(_v1);
+      position.setXYZ(idx, _v1.x, _v1.y, _v1.z);
+      idx = idx + 1;
+      position.setXYZ(idx, _v2.x, _v2.y, _v2.z);
+      idx = idx + 1;
+    }
+    position.needsUpdate = true;
+  }
+}
+exports.VertexTangentsHelper = VertexTangentsHelper;