@playdrop/playdrop-cli 0.3.5-build.1 → 0.3.8-build.2

package/node_modules/three/examples/jsm/modifiers/CurveModifier.js

@@ -5,12 +5,13 @@ const TEXTURE_HEIGHT = 4;
 
 import {
 	DataTexture,
+	DataUtils,
 	RGBAFormat,
-	FloatType,
+	HalfFloatType,
 	RepeatWrapping,
 	Mesh,
 	InstancedMesh,
-	NearestFilter,
+	LinearFilter,
 	DynamicDrawUsage,
 	Matrix4
 } from 'three';
@@ -18,22 +19,25 @@ import {
 /**
  * Make a new DataTexture to store the descriptions of the curves.
  *
- * @param { number } numberOfCurves the number of curves needed to be described by this texture.
+ * @private
+ * @param {number} numberOfCurves - The number of curves needed to be described by this texture.
+ * @returns {DataTexture}
  */
-export function initSplineTexture( numberOfCurves = 1 ) {
+function initSplineTexture( numberOfCurves = 1 ) {
 
-	const dataArray = new Float32Array( TEXTURE_WIDTH * TEXTURE_HEIGHT * numberOfCurves * CHANNELS );
+	const dataArray = new Uint16Array( TEXTURE_WIDTH * TEXTURE_HEIGHT * numberOfCurves * CHANNELS );
 	const dataTexture = new DataTexture(
 		dataArray,
 		TEXTURE_WIDTH,
 		TEXTURE_HEIGHT * numberOfCurves,
 		RGBAFormat,
-		FloatType
+		HalfFloatType
 	);
 
 	dataTexture.wrapS = RepeatWrapping;
 	dataTexture.wrapY = RepeatWrapping;
-	dataTexture.magFilter = NearestFilter;
+	dataTexture.magFilter = LinearFilter;
+	dataTexture.minFilter = LinearFilter;
 	dataTexture.needsUpdate = true;
 
 	return dataTexture;
@@ -41,13 +45,14 @@ export function initSplineTexture( numberOfCurves = 1 ) {
 }
 
 /**
- * Write the curve description to the data texture
+ * Write the curve description to the data texture.
  *
- * @param { DataTexture } texture The DataTexture to write to
- * @param { Curve } splineCurve The curve to describe
- * @param { number } offset Which curve slot to write to
+ * @private
+ * @param {DataTexture} texture - The data texture to write to.
+ * @param {Curve} splineCurve - The curve to describe.
+ * @param {number} offset - Which curve slot to write to.
  */
-export function updateSplineTexture( texture, splineCurve, offset = 0 ) {
+function updateSplineTexture( texture, splineCurve, offset = 0 ) {
 
 	const numberOfPoints = Math.floor( TEXTURE_WIDTH * ( TEXTURE_HEIGHT / 4 ) );
 	splineCurve.arcLengthDivisions = numberOfPoints / 2;
@@ -75,25 +80,25 @@ export function updateSplineTexture( texture, splineCurve, offset = 0 ) {
 
 }
 
-
 function setTextureValue( texture, index, x, y, z, o ) {
 
 	const image = texture.image;
 	const { data } = image;
 	const i = CHANNELS * TEXTURE_WIDTH * o; // Row Offset
-	data[ index * CHANNELS + i + 0 ] = x;
-	data[ index * CHANNELS + i + 1 ] = y;
-	data[ index * CHANNELS + i + 2 ] = z;
-	data[ index * CHANNELS + i + 3 ] = 1;
+	data[ index * CHANNELS + i + 0 ] = DataUtils.toHalfFloat( x );
+	data[ index * CHANNELS + i + 1 ] = DataUtils.toHalfFloat( y );
+	data[ index * CHANNELS + i + 2 ] = DataUtils.toHalfFloat( z );
+	data[ index * CHANNELS + i + 3 ] = DataUtils.toHalfFloat( 1 );
 
 }
 
 /**
- * Create a new set of uniforms for describing the curve modifier
+ * Create a new set of uniforms for describing the curve modifier.
  *
- * @param { DataTexture } Texture which holds the curve description
+ * @param {DataTexture} splineTexture - Which holds the curve description.
+ * @returns {Object} The uniforms object to be used in the shader.
  */
-export function getUniforms( splineTexture ) {
+function getUniforms( splineTexture ) {
 
 	const uniforms = {
 		spineTexture: { value: splineTexture },
@@ -107,7 +112,7 @@ export function getUniforms( splineTexture ) {
 
 }
 
-export function modifyShader( material, uniforms, numberOfCurves = 1 ) {
+function modifyShader( material, uniforms, numberOfCurves = 1 ) {
 
 	if ( material.__ok ) return;
 	material.__ok = true;
@@ -135,10 +140,10 @@ export function modifyShader( material, uniforms, numberOfCurves = 1 ) {
 		// chunk import moved in front of modified shader below
 			.replace( '#include <beginnormal_vertex>', '' )
 
-			// vec3 transformedNormal declaration overriden below
+			// vec3 transformedNormal declaration overridden below
 			.replace( '#include <defaultnormal_vertex>', '' )
 
-			// vec3 transformed declaration overriden below
+			// vec3 transformed declaration overridden below
 			.replace( '#include <begin_vertex>', '' )
 
 			// shader override
@@ -194,19 +199,26 @@ vec3 transformedNormal = normalMatrix * (basis * objectNormal);
 }
 
 /**
- * A helper class for making meshes bend aroudn curves
+ * A modifier for making meshes bend around curves.
+ *
+ * This module can only be used with {@link WebGLRenderer}. When using {@link WebGPURenderer},
+ * import the class from `CurveModifierGPU.js`.
+ *
+ * @three_import import { Flow } from 'three/addons/modifiers/CurveModifier.js';
  */
 export class Flow {
 
 	/**
-	 * @param {Mesh} mesh The mesh to clone and modify to bend around the curve
-	 * @param {number} numberOfCurves The amount of space that should preallocated for additional curves
+	 * Constructs a new Flow instance.
+	 *
+	 * @param {Mesh} mesh - The mesh to clone and modify to bend around the curve.
+	 * @param {number} numberOfCurves - The amount of space that should preallocated for additional curves.
 	 */
 	constructor( mesh, numberOfCurves = 1 ) {
 
 		const obj3D = mesh.clone();
-		const splineTexure = initSplineTexture( numberOfCurves );
-		const uniforms = getUniforms( splineTexure );
+		const splineTexture = initSplineTexture( numberOfCurves );
+		const uniforms = getUniforms( splineTexture );
 		obj3D.traverse( function ( child ) {
 
 			if (
@@ -243,22 +255,33 @@ export class Flow {
 		this.curveLengthArray = new Array( numberOfCurves );
 
 		this.object3D = obj3D;
-		this.splineTexure = splineTexure;
+		this.splineTexture = splineTexture;
 		this.uniforms = uniforms;
 
 	}
 
+	/**
+	 * Updates the curve for the given curve index.
+	 *
+	 * @param {number} index - The curve index.
+	 * @param {Curve} curve - The curve that should be used to bend the mesh.
+	 */
 	updateCurve( index, curve ) {
 
-		if ( index >= this.curveArray.length ) throw Error( 'Index out of range for Flow' );
+		if ( index >= this.curveArray.length ) throw Error( 'Flow: Index out of range.' );
 		const curveLength = curve.getLength();
 		this.uniforms.spineLength.value = curveLength;
 		this.curveLengthArray[ index ] = curveLength;
 		this.curveArray[ index ] = curve;
-		updateSplineTexture( this.splineTexure, curve, index );
+		updateSplineTexture( this.splineTexture, curve, index );
 
 	}
 
+	/**
+	 * Moves the mesh along the curve.
+	 *
+	 * @param {number} amount - The offset.
+	 */
 	moveAlongCurve( amount ) {
 
 		this.uniforms.pathOffset.value += amount;
@@ -266,19 +289,26 @@ export class Flow {
 	}
 
 }
-const matrix = new Matrix4();
+
+const _matrix = new Matrix4();
 
 /**
- * A helper class for creating instanced versions of flow, where the instances are placed on the curve.
+ * An instanced version of {@link Flow} for making meshes bend around curves, where the instances are placed on the curve.
+ *
+ * This module can only be used with {@link WebGLRenderer}.
+ *
+ * @augments Flow
+ * @three_import import { InstancedFlow } from 'three/addons/modifiers/CurveModifier.js';
  */
 export class InstancedFlow extends Flow {
 
 	/**
+	 * Constructs a new InstancedFlow instance.
 	 *
-	 * @param {number} count The number of instanced elements
-	 * @param {number} curveCount The number of curves to preallocate for
-	 * @param {Geometry} geometry The geometry to use for the instanced mesh
-	 * @param {Material} material The material to use for the instanced mesh
+	 * @param {number} count - The number of instanced elements.
+	 * @param {number} curveCount - The number of curves to preallocate for.
+	 * @param {Geometry} geometry - The geometry to use for the instanced mesh.
+	 * @param {Material} material - The material to use for the instanced mesh.
 	 */
 	constructor( count, curveCount, geometry, material ) {
 
@@ -300,25 +330,25 @@ export class InstancedFlow extends Flow {
 	 * The extra information about which curve and curve position is stored in the translation components of the matrix for the instanced objects
 	 * This writes that information to the matrix and marks it as needing update.
 	 *
-	 * @param {number} index of the instanced element to update
+	 * @param {number} index - The index of tge instanced element to update.
 	 */
 	writeChanges( index ) {
 
-		matrix.makeTranslation(
+		_matrix.makeTranslation(
 			this.curveLengthArray[ this.whichCurve[ index ] ],
 			this.whichCurve[ index ],
 			this.offsets[ index ]
 		);
-		this.object3D.setMatrixAt( index, matrix );
+		this.object3D.setMatrixAt( index, _matrix );
 		this.object3D.instanceMatrix.needsUpdate = true;
 
 	}
 
 	/**
-	 * Move an individual element along the curve by a specific amount
+	 * Move an individual element along the curve by a specific amount.
 	 *
-	 * @param {number} index Which element to update
-	 * @param {number} offset Move by how much
+	 * @param {number} index - Which element to update.
+	 * @param {number} offset - The offset.
 	 */
 	moveIndividualAlongCurve( index, offset ) {
 
@@ -328,14 +358,14 @@ export class InstancedFlow extends Flow {
 	}
 
 	/**
-	 * Select which curve to use for an element
+	 * Select which curve to use for an element.
 	 *
-	 * @param {number} index the index of the instanced element to update
-	 * @param {number} curveNo the index of the curve it should use
+	 * @param {number} index - The index of the instanced element to update.
+	 * @param {number} curveNo - The index of the curve it should use.
 	 */
 	setCurve( index, curveNo ) {
 
-		if ( isNaN( curveNo ) ) throw Error( 'curve index being set is Not a Number (NaN)' );
+		if ( isNaN( curveNo ) ) throw Error( 'InstancedFlow: Curve index being set is Not a Number (NaN).' );
 		this.whichCurve[ index ] = curveNo;
 		this.writeChanges( index );
 

package/node_modules/three/examples/jsm/modifiers/CurveModifierGPU.js

@@ -0,0 +1,256 @@
+// Original src: https://github.com/zz85/threejs-path-flow
+const CHANNELS = 4;
+const TEXTURE_WIDTH = 1024;
+const TEXTURE_HEIGHT = 4;
+
+import {
+	DataTexture,
+	DataUtils,
+	RGBAFormat,
+	HalfFloatType,
+	RepeatWrapping,
+	Mesh,
+	InstancedMesh,
+	LinearFilter
+} from 'three';
+
+import { modelWorldMatrix, normalLocal, vec2, vec3, vec4, mat3, varyingProperty, texture, reference, Fn, select, positionLocal } from 'three/tsl';
+
+/**
+ * Make a new DataTexture to store the descriptions of the curves.
+ *
+ * @private
+ * @param {number} [numberOfCurves=1] - The number of curves needed to be described by this texture.
+ * @returns  {DataTexture} The new data texture.
+ */
+function initSplineTexture( numberOfCurves = 1 ) {
+
+	const dataArray = new Uint16Array( TEXTURE_WIDTH * TEXTURE_HEIGHT * numberOfCurves * CHANNELS );
+	const dataTexture = new DataTexture(
+		dataArray,
+		TEXTURE_WIDTH,
+		TEXTURE_HEIGHT * numberOfCurves,
+		RGBAFormat,
+		HalfFloatType
+	);
+
+	dataTexture.wrapS = RepeatWrapping;
+	dataTexture.wrapY = RepeatWrapping;
+	dataTexture.magFilter = LinearFilter;
+	dataTexture.minFilter = LinearFilter;
+	dataTexture.needsUpdate = true;
+
+	return dataTexture;
+
+}
+
+/**
+ * Write the curve description to the data texture.
+ *
+ * @private
+ * @param {DataTexture} texture - The data texture to write to.
+ * @param {Curve} splineCurve - The curve to describe.
+ * @param {number} [offset=0] - Which curve slot to write to.
+ */
+function updateSplineTexture( texture, splineCurve, offset = 0 ) {
+
+	const numberOfPoints = Math.floor( TEXTURE_WIDTH * ( TEXTURE_HEIGHT / 4 ) );
+	splineCurve.arcLengthDivisions = numberOfPoints / 2;
+	splineCurve.updateArcLengths();
+	const points = splineCurve.getSpacedPoints( numberOfPoints );
+	const frenetFrames = splineCurve.computeFrenetFrames( numberOfPoints, true );
+
+	for ( let i = 0; i < numberOfPoints; i ++ ) {
+
+		const rowOffset = Math.floor( i / TEXTURE_WIDTH );
+		const rowIndex = i % TEXTURE_WIDTH;
+
+		let pt = points[ i ];
+		setTextureValue( texture, rowIndex, pt.x, pt.y, pt.z, 0 + rowOffset + ( TEXTURE_HEIGHT * offset ) );
+		pt = frenetFrames.tangents[ i ];
+		setTextureValue( texture, rowIndex, pt.x, pt.y, pt.z, 1 + rowOffset + ( TEXTURE_HEIGHT * offset ) );
+		pt = frenetFrames.normals[ i ];
+		setTextureValue( texture, rowIndex, pt.x, pt.y, pt.z, 2 + rowOffset + ( TEXTURE_HEIGHT * offset ) );
+		pt = frenetFrames.binormals[ i ];
+		setTextureValue( texture, rowIndex, pt.x, pt.y, pt.z, 3 + rowOffset + ( TEXTURE_HEIGHT * offset ) );
+
+	}
+
+	texture.needsUpdate = true;
+
+}
+
+
+function setTextureValue( texture, index, x, y, z, o ) {
+
+	const image = texture.image;
+	const { data } = image;
+	const i = CHANNELS * TEXTURE_WIDTH * o; // Row Offset
+
+	data[ index * CHANNELS + i + 0 ] = DataUtils.toHalfFloat( x );
+	data[ index * CHANNELS + i + 1 ] = DataUtils.toHalfFloat( y );
+	data[ index * CHANNELS + i + 2 ] = DataUtils.toHalfFloat( z );
+	data[ index * CHANNELS + i + 3 ] = DataUtils.toHalfFloat( 1 );
+
+}
+
+/**
+ * Create a new set of uniforms for describing the curve modifier.
+ *
+ * @private
+ * @param {DataTexture} splineTexture - Which holds the curve description.
+ * @returns {Object} The uniforms object.
+ */
+function getUniforms( splineTexture ) {
+
+	return {
+		spineTexture: splineTexture,
+		pathOffset: 0, // time of path curve
+		pathSegment: 1, // fractional length of path
+		spineOffset: 161,
+		spineLength: 400,
+		flow: 1, // int
+	};
+
+}
+
+function modifyShader( material, uniforms, numberOfCurves ) {
+
+	const spineTexture = uniforms.spineTexture;
+
+	const pathOffset = reference( 'pathOffset', 'float', uniforms );
+	const pathSegment = reference( 'pathSegment', 'float', uniforms );
+	const spineOffset = reference( 'spineOffset', 'float', uniforms );
+	const spineLength = reference( 'spineLength', 'float', uniforms );
+	const flow = reference( 'flow', 'float', uniforms );
+
+	material.positionNode = Fn( () => {
+
+		const textureStacks = TEXTURE_HEIGHT / 4;
+		const textureScale = TEXTURE_HEIGHT * numberOfCurves;
+
+		const worldPos = modelWorldMatrix.mul( vec4( positionLocal, 1 ) ).toVar();
+
+		const bend = flow.greaterThan( 0 ).toVar();
+		const xWeight = select( bend, 0, 1 ).toVar();
+
+		const spinePortion = select( bend, worldPos.x.add( spineOffset ).div( spineLength ), 0 );
+		const mt = spinePortion.mul( pathSegment ).add( pathOffset ).mul( textureStacks ).toVar();
+
+		mt.assign( mt.mod( textureStacks ) );
+
+		const rowOffset = mt.floor().toVar();
+
+		const spinePos = texture( spineTexture, vec2( mt, rowOffset.add( 0.5 ).div( textureScale ) ) ).xyz;
+
+		const a = texture( spineTexture, vec2( mt, rowOffset.add( 1.5 ).div( textureScale ) ) ).xyz;
+		const b = texture( spineTexture, vec2( mt, rowOffset.add( 2.5 ).div( textureScale ) ) ).xyz;
+		const c = texture( spineTexture, vec2( mt, rowOffset.add( 3.5 ).div( textureScale ) ) ).xyz;
+
+		const basis = mat3( a, b, c ).toVar();
+
+		varyingProperty( 'vec3', 'curveNormal' ).assign( basis.mul( normalLocal ) );
+
+		return basis.mul( vec3( worldPos.x.mul( xWeight ), worldPos.y, worldPos.z ) ).add( spinePos );
+
+	} )();
+
+	material.normalNode = varyingProperty( 'vec3', 'curveNormal' );
+
+}
+
+/**
+ * A modifier for making meshes bend around curves.
+ *
+ * This module can only be used with {@link WebGPURenderer}. When using {@link WebGLRenderer},
+ * import the class from `CurveModifier.js`.
+ *
+ * @three_import import { Flow } from 'three/addons/modifiers/CurveModifierGPU.js';
+ */
+export class Flow {
+
+	/**
+	 * Constructs a new Flow instance.
+	 *
+	 * @param {Mesh} mesh - The mesh to clone and modify to bend around the curve.
+	 * @param {number} numberOfCurves - The amount of space that should preallocated for additional curves.
+	 */
+	constructor( mesh, numberOfCurves = 1 ) {
+
+		const obj3D = mesh.clone();
+		const splineTexture = initSplineTexture( numberOfCurves );
+		const uniforms = getUniforms( splineTexture );
+
+		obj3D.traverse( function ( child ) {
+
+			if (
+				child instanceof Mesh ||
+				child instanceof InstancedMesh
+			) {
+
+				if ( Array.isArray( child.material ) ) {
+
+					const materials = [];
+
+					for ( const material of child.material ) {
+
+						const newMaterial = material.clone();
+						modifyShader( newMaterial, uniforms, numberOfCurves );
+						materials.push( newMaterial );
+
+					}
+
+					child.material = materials;
+
+				} else {
+
+					child.material = child.material.clone();
+					modifyShader( child.material, uniforms, numberOfCurves );
+
+				}
+
+			}
+
+		} );
+
+		this.curveArray = new Array( numberOfCurves );
+		this.curveLengthArray = new Array( numberOfCurves );
+
+		this.object3D = obj3D;
+		this.splineTexture = splineTexture;
+		this.uniforms = uniforms;
+
+	}
+
+	/**
+	 * Updates the curve for the given curve index.
+	 *
+	 * @param {number} index - The curve index.
+	 * @param {Curve} curve - The curve that should be used to bend the mesh.
+	 */
+	updateCurve( index, curve ) {
+
+		if ( index >= this.curveArray.length ) throw Error( 'Flow: Index out of range.' );
+
+		const curveLength = curve.getLength();
+
+		this.uniforms.spineLength = curveLength;
+		this.curveLengthArray[ index ] = curveLength;
+		this.curveArray[ index ] = curve;
+
+		updateSplineTexture( this.splineTexture, curve, index );
+
+	}
+
+	/**
+	 * Moves the mesh along the curve.
+	 *
+	 * @param {number} amount - The offset.
+	 */
+	moveAlongCurve( amount ) {
+
+		this.uniforms.pathOffset += amount;
+
+	}
+
+}

package/node_modules/three/examples/jsm/modifiers/EdgeSplitModifier.js

@@ -9,8 +9,28 @@ const _A = new Vector3();
 const _B = new Vector3();
 const _C = new Vector3();
 
+/**
+ * The modifier can be used to split faces at sharp edges. This allows to compute
+ * normals without smoothing the edges which can lead to an improved visual result.
+ *
+ * ```js
+ * const modifier = new EdgeSplitModifier();
+ * geometry = modifier.modify( geometry, Math.PI * 0.4 );
+ * ```
+ *
+ * @three_import import { EdgeSplitModifier } from 'three/addons/modifiers/EdgeSplitModifier.js';
+ */
 class EdgeSplitModifier {
 
+	/**
+	 * Returns a new, modified version of the given geometry by applying an edge-split operation.
+	 * Please note that the resulting geometry is always indexed.
+	 *
+	 * @param {BufferGeometry} geometry - The geometry to modify.
+	 * @param {number} cutOffAngle - The cut off angle in radians.
+	 * @param {boolean} [tryKeepNormals=true] - Whether to try to keep normals or not.
+	 * @return {BufferGeometry} A new, modified geometry.
+	 */
 	modify( geometry, cutOffAngle, tryKeepNormals = true ) {
 
 		function computeNormals() {

package/node_modules/three/examples/jsm/modifiers/SimplifyModifier.js

@@ -1,5 +1,6 @@
 import {
 	BufferGeometry,
+	Color,
 	Float32BufferAttribute,
 	Vector2,
 	Vector3,
@@ -7,18 +8,32 @@ import {
 } from 'three';
 import * as BufferGeometryUtils from '../utils/BufferGeometryUtils.js';
 
-/**
- *	Simplification Geometry Modifier
- *    - based on code and technique
- *	  - by Stan Melax in 1998
- *	  - Progressive Mesh type Polygon Reduction Algorithm
- *    - http://www.melax.com/polychop/
- */
-
 const _cb = new Vector3(), _ab = new Vector3();
 
+/**
+ * This class can be used to modify a geometry by simplifying it. A typical use
+ * case for such a modifier is automatic LOD generation.
+ *
+ * The implementation is based on [Progressive Mesh type Polygon Reduction Algorithm](https://web.archive.org/web/20230610044040/http://www.melax.com/polychop/)
+ * by Stan Melax in 1998.
+ *
+ * ```js
+ * const modifier = new SimplifyModifier();
+ * geometry = modifier.modify( geometry );
+ * ```
+ *
+ * @three_import import { SimplifyModifier } from 'three/addons/modifiers/SimplifyModifier.js';
+ */
 class SimplifyModifier {
 
+	/**
+	 * Returns a new, modified version of the given geometry by applying a simplification.
+	 * Please note that the resulting geometry is always non-indexed.
+	 *
+	 * @param {BufferGeometry} geometry - The geometry to modify.
+	 * @param {number} count - The number of vertices to remove.
+	 * @return {BufferGeometry} A new, modified geometry.
+	 */
 	modify( geometry, count ) {
 
 		geometry = geometry.clone();
@@ -28,7 +43,7 @@ class SimplifyModifier {
 		delete geometry.morphAttributes.normal;
 		const attributes = geometry.attributes;
 
-		// this modifier can only process indexed and non-indexed geomtries with at least a position attribute
+		// this modifier can only process indexed and non-indexed geometries with at least a position attribute
 
 		for ( const name in attributes ) {
 
@@ -81,7 +96,7 @@ class SimplifyModifier {
 
 			if ( colorAttribute ) {
 
-				col = new THREE.Color().fromBufferAttribute( colorAttribute, i );
+				col = new Color().fromBufferAttribute( colorAttribute, i );
 
 			}
 
@@ -583,7 +598,7 @@ class Vertex {
 
 		// these will be computed in computeEdgeCostAtVertex()
 		this.collapseCost = 0; // cost of collapsing this vertex, the less the better. aka objdist
-		this.collapseNeighbor = null; // best candinate for collapsing
+		this.collapseNeighbor = null; // best candidate for collapsing
 
 	}
 

package/node_modules/three/examples/jsm/modifiers/TessellateModifier.js

@@ -7,18 +7,51 @@ import {
 } from 'three';
 
 /**
- * Break faces with edges longer than maxEdgeLength
+ * This class can be used to modify a geometry by breaking its edges if they
+ * are longer than maximum length.
+ *
+ * ```js
+ * const modifier = new TessellateModifier( 8, 6 );
+ * geometry = modifier.modify( geometry );
+ * ```
+ *
+ * @three_import import { TessellateModifier } from 'three/addons/modifiers/TessellateModifier.js';
  */
-
 class TessellateModifier {
 
+	/**
+	 * Constructs a new Tessellate modifier.
+	 *
+	 * @param {number} [maxEdgeLength=0.1] - The maximum edge length.
+	 * @param {number} [maxIterations=6] - The number of iterations.
+	 */
 	constructor( maxEdgeLength = 0.1, maxIterations = 6 ) {
 
+		/**
+		 * The maximum edge length.
+		 *
+		 * @type {number}
+		 * @default 0.1
+		 */
 		this.maxEdgeLength = maxEdgeLength;
+
+		/**
+		 * The maximum edge length.
+		 *
+		 * @type {number}
+		 * @default 0.1
+		 */
 		this.maxIterations = maxIterations;
 
 	}
 
+	/**
+	 * Returns a new, modified version of the given geometry by applying a tesselation.
+	 * Please note that the resulting geometry is always non-indexed.
+	 *
+	 * @param {BufferGeometry} geometry - The geometry to modify.
+	 * @return {BufferGeometry} A new, modified geometry.
+	 */
 	modify( geometry ) {
 
 		if ( geometry.index !== null ) {