@lampdotdev/lamp 0.0.0-stage → 0.35.0

package/Resources/WebLibraries/three/addons/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/Resources/WebLibraries/three/addons/modifiers/EdgeSplitModifier.js

@@ -0,0 +1,299 @@
+import {
+	BufferAttribute,
+	BufferGeometry,
+	Vector3
+} from 'three';
+import * as BufferGeometryUtils from '../utils/BufferGeometryUtils.js';
+
+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() {
+
+			normals = new Float32Array( indexes.length * 3 );
+
+			for ( let i = 0; i < indexes.length; i += 3 ) {
+
+				let index = indexes[ i ];
+
+				_A.set(
+					positions[ 3 * index ],
+					positions[ 3 * index + 1 ],
+					positions[ 3 * index + 2 ] );
+
+				index = indexes[ i + 1 ];
+				_B.set(
+					positions[ 3 * index ],
+					positions[ 3 * index + 1 ],
+					positions[ 3 * index + 2 ] );
+
+				index = indexes[ i + 2 ];
+				_C.set(
+					positions[ 3 * index ],
+					positions[ 3 * index + 1 ],
+					positions[ 3 * index + 2 ] );
+
+				_C.sub( _B );
+				_A.sub( _B );
+
+				const normal = _C.cross( _A ).normalize();
+
+				for ( let j = 0; j < 3; j ++ ) {
+
+					normals[ 3 * ( i + j ) ] = normal.x;
+					normals[ 3 * ( i + j ) + 1 ] = normal.y;
+					normals[ 3 * ( i + j ) + 2 ] = normal.z;
+
+				}
+
+			}
+
+		}
+
+
+		function mapPositionsToIndexes() {
+
+			pointToIndexMap = Array( positions.length / 3 );
+
+			for ( let i = 0; i < indexes.length; i ++ ) {
+
+				const index = indexes[ i ];
+
+				if ( pointToIndexMap[ index ] == null ) {
+
+					pointToIndexMap[ index ] = [];
+
+				}
+
+				pointToIndexMap[ index ].push( i );
+
+			}
+
+		}
+
+
+		function edgeSplitToGroups( indexes, cutOff, firstIndex ) {
+
+			_A.set( normals[ 3 * firstIndex ], normals[ 3 * firstIndex + 1 ], normals[ 3 * firstIndex + 2 ] ).normalize();
+
+			const result = {
+				splitGroup: [],
+				currentGroup: [ firstIndex ]
+			};
+
+			for ( const j of indexes ) {
+
+				if ( j !== firstIndex ) {
+
+					_B.set( normals[ 3 * j ], normals[ 3 * j + 1 ], normals[ 3 * j + 2 ] ).normalize();
+
+					if ( _B.dot( _A ) < cutOff ) {
+
+						result.splitGroup.push( j );
+
+					} else {
+
+						result.currentGroup.push( j );
+
+					}
+
+				}
+
+			}
+
+			return result;
+
+		}
+
+
+		function edgeSplit( indexes, cutOff, original = null ) {
+
+			if ( indexes.length === 0 ) return;
+
+			const groupResults = [];
+
+			for ( const index of indexes ) {
+
+				groupResults.push( edgeSplitToGroups( indexes, cutOff, index ) );
+
+			}
+
+			let result = groupResults[ 0 ];
+
+			for ( const groupResult of groupResults ) {
+
+				if ( groupResult.currentGroup.length > result.currentGroup.length ) {
+
+					result = groupResult;
+
+				}
+
+			}
+
+
+			if ( original != null ) {
+
+				splitIndexes.push( {
+					original: original,
+					indexes: result.currentGroup
+				} );
+
+			}
+
+			if ( result.splitGroup.length ) {
+
+				edgeSplit( result.splitGroup, cutOff, original || result.currentGroup[ 0 ] );
+
+			}
+
+		}
+
+		let hadNormals = false;
+		let oldNormals = null;
+
+		if ( geometry.attributes.normal ) {
+
+			hadNormals = true;
+
+			geometry = geometry.clone();
+
+			if ( tryKeepNormals === true && geometry.index !== null ) {
+
+				oldNormals = geometry.attributes.normal.array;
+
+			}
+
+			geometry.deleteAttribute( 'normal' );
+
+		}
+
+		if ( geometry.index == null ) {
+
+			geometry = BufferGeometryUtils.mergeVertices( geometry );
+
+		}
+
+		const indexes = geometry.index.array;
+		const positions = geometry.getAttribute( 'position' ).array;
+
+		let normals;
+		let pointToIndexMap;
+
+		computeNormals();
+		mapPositionsToIndexes();
+
+		const splitIndexes = [];
+
+		for ( const vertexIndexes of pointToIndexMap ) {
+
+			edgeSplit( vertexIndexes, Math.cos( cutOffAngle ) - 0.001 );
+
+		}
+
+		const newAttributes = {};
+		for ( const name of Object.keys( geometry.attributes ) ) {
+
+			const oldAttribute = geometry.attributes[ name ];
+			const newArray = new oldAttribute.array.constructor( ( indexes.length + splitIndexes.length ) * oldAttribute.itemSize );
+			newArray.set( oldAttribute.array );
+			newAttributes[ name ] = new BufferAttribute( newArray, oldAttribute.itemSize, oldAttribute.normalized );
+
+		}
+
+		const newIndexes = new Uint32Array( indexes.length );
+		newIndexes.set( indexes );
+
+		for ( let i = 0; i < splitIndexes.length; i ++ ) {
+
+			const split = splitIndexes[ i ];
+			const index = indexes[ split.original ];
+
+			for ( const attribute of Object.values( newAttributes ) ) {
+
+				for ( let j = 0; j < attribute.itemSize; j ++ ) {
+
+					attribute.array[ ( indexes.length + i ) * attribute.itemSize + j ] =
+						attribute.array[ index * attribute.itemSize + j ];
+
+				}
+
+			}
+
+			for ( const j of split.indexes ) {
+
+				newIndexes[ j ] = indexes.length + i;
+
+			}
+
+		}
+
+		geometry = new BufferGeometry();
+		geometry.setIndex( new BufferAttribute( newIndexes, 1 ) );
+
+		for ( const name of Object.keys( newAttributes ) ) {
+
+			geometry.setAttribute( name, newAttributes[ name ] );
+
+		}
+
+		if ( hadNormals ) {
+
+			geometry.computeVertexNormals();
+
+			if ( oldNormals !== null ) {
+
+				const changedNormals = new Array( oldNormals.length / 3 ).fill( false );
+
+				for ( const splitData of splitIndexes )
+					changedNormals[ splitData.original ] = true;
+
+				for ( let i = 0; i < changedNormals.length; i ++ ) {
+
+					if ( changedNormals[ i ] === false ) {
+
+						for ( let j = 0; j < 3; j ++ )
+							geometry.attributes.normal.array[ 3 * i + j ] = oldNormals[ 3 * i + j ];
+
+					}
+
+				}
+
+
+			}
+
+		}
+
+		return geometry;
+
+	}
+
+}
+
+
+
+export { EdgeSplitModifier };