@needle-tools/three 0.146.10 → 0.153.1

package/examples/js/modifiers/CurveModifier.js

@@ -1,309 +0,0 @@
-( function () {
-
-	// Original src: https://github.com/zz85/threejs-path-flow
-	const CHANNELS = 4;
-	const TEXTURE_WIDTH = 1024;
-	const TEXTURE_HEIGHT = 4;
-
-	/**
- * Make a new THREE.DataTexture to store the descriptions of the curves.
- *
- * @param { number } numberOfCurves the number of curves needed to be described by this texture.
- */
-	function initSplineTexture( numberOfCurves = 1 ) {
-
-		const dataArray = new Float32Array( TEXTURE_WIDTH * TEXTURE_HEIGHT * numberOfCurves * CHANNELS );
-		const dataTexture = new THREE.DataTexture( dataArray, TEXTURE_WIDTH, TEXTURE_HEIGHT * numberOfCurves, THREE.RGBAFormat, THREE.FloatType );
-		dataTexture.wrapS = THREE.RepeatWrapping;
-		dataTexture.wrapY = THREE.RepeatWrapping;
-		dataTexture.magFilter = THREE.NearestFilter;
-		dataTexture.needsUpdate = true;
-		return dataTexture;
-
-	}
-
-	/**
- * Write the curve description to the data texture
- *
- * @param { THREE.DataTexture } texture The THREE.DataTexture to write to
- * @param { Curve } splineCurve The curve to describe
- * @param { number } offset 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 ] = x;
-		data[ index * CHANNELS + i + 1 ] = y;
-		data[ index * CHANNELS + i + 2 ] = z;
-		data[ index * CHANNELS + i + 3 ] = 1;
-
-	}
-
-	/**
- * Create a new set of uniforms for describing the curve modifier
- *
- * @param { THREE.DataTexture } Texture which holds the curve description
- */
-	function getUniforms( splineTexture ) {
-
-		const uniforms = {
-			spineTexture: {
-				value: splineTexture
-			},
-			pathOffset: {
-				type: 'f',
-				value: 0
-			},
-			// time of path curve
-			pathSegment: {
-				type: 'f',
-				value: 1
-			},
-			// fractional length of path
-			spineOffset: {
-				type: 'f',
-				value: 161
-			},
-			spineLength: {
-				type: 'f',
-				value: 400
-			},
-			flow: {
-				type: 'i',
-				value: 1
-			}
-		};
-		return uniforms;
-
-	}
-
-	function modifyShader( material, uniforms, numberOfCurves = 1 ) {
-
-		if ( material.__ok ) return;
-		material.__ok = true;
-		material.onBeforeCompile = shader => {
-
-			if ( shader.__modified ) return;
-			shader.__modified = true;
-			Object.assign( shader.uniforms, uniforms );
-			const vertexShader = `
-		uniform sampler2D spineTexture;
-		uniform float pathOffset;
-		uniform float pathSegment;
-		uniform float spineOffset;
-		uniform float spineLength;
-		uniform int flow;
-
-		float textureLayers = ${TEXTURE_HEIGHT * numberOfCurves}.;
-		float textureStacks = ${TEXTURE_HEIGHT / 4}.;
-
-		${shader.vertexShader}
-		`
-			// chunk import moved in front of modified shader below
-				.replace( '#include <beginnormal_vertex>', '' )
-
-			// vec3 transformedNormal declaration overriden below
-				.replace( '#include <defaultnormal_vertex>', '' )
-
-			// vec3 transformed declaration overriden below
-				.replace( '#include <begin_vertex>', '' )
-
-			// shader override
-				.replace( /void\s*main\s*\(\)\s*\{/, `
-void main() {
-#include <beginnormal_vertex>
-
-vec4 worldPos = modelMatrix * vec4(position, 1.);
-
-bool bend = flow > 0;
-float xWeight = bend ? 0. : 1.;
-
-#ifdef USE_INSTANCING
-float pathOffsetFromInstanceMatrix = instanceMatrix[3][2];
-float spineLengthFromInstanceMatrix = instanceMatrix[3][0];
-float spinePortion = bend ? (worldPos.x + spineOffset) / spineLengthFromInstanceMatrix : 0.;
-float mt = (spinePortion * pathSegment + pathOffset + pathOffsetFromInstanceMatrix)*textureStacks;
-#else
-float spinePortion = bend ? (worldPos.x + spineOffset) / spineLength : 0.;
-float mt = (spinePortion * pathSegment + pathOffset)*textureStacks;
-#endif
-
-mt = mod(mt, textureStacks);
-float rowOffset = floor(mt);
-
-#ifdef USE_INSTANCING
-rowOffset += instanceMatrix[3][1] * ${TEXTURE_HEIGHT}.;
-#endif
-
-vec3 spinePos = texture2D(spineTexture, vec2(mt, (0. + rowOffset + 0.5) / textureLayers)).xyz;
-vec3 a =        texture2D(spineTexture, vec2(mt, (1. + rowOffset + 0.5) / textureLayers)).xyz;
-vec3 b =        texture2D(spineTexture, vec2(mt, (2. + rowOffset + 0.5) / textureLayers)).xyz;
-vec3 c =        texture2D(spineTexture, vec2(mt, (3. + rowOffset + 0.5) / textureLayers)).xyz;
-mat3 basis = mat3(a, b, c);
-
-vec3 transformed = basis
-	* vec3(worldPos.x * xWeight, worldPos.y * 1., worldPos.z * 1.)
-	+ spinePos;
-
-vec3 transformedNormal = normalMatrix * (basis * objectNormal);
-			` ).replace( '#include <project_vertex>', `vec4 mvPosition = modelViewMatrix * vec4( transformed, 1.0 );
-				gl_Position = projectionMatrix * mvPosition;` );
-			shader.vertexShader = vertexShader;
-
-		};
-
-	}
-
-	/**
- * A helper class for making meshes bend aroudn curves
- */
-	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
-   */
-		constructor( mesh, numberOfCurves = 1 ) {
-
-			const obj3D = mesh.clone();
-			const splineTexure = initSplineTexture( numberOfCurves );
-			const uniforms = getUniforms( splineTexure );
-			obj3D.traverse( function ( child ) {
-
-				if ( child instanceof THREE.Mesh || child instanceof THREE.InstancedMesh ) {
-
-					child.material = child.material.clone();
-					modifyShader( child.material, uniforms, numberOfCurves );
-
-				}
-
-			} );
-			this.curveArray = new Array( numberOfCurves );
-			this.curveLengthArray = new Array( numberOfCurves );
-			this.object3D = obj3D;
-			this.splineTexure = splineTexure;
-			this.uniforms = uniforms;
-
-		}
-		updateCurve( index, curve ) {
-
-			if ( index >= this.curveArray.length ) throw Error( 'Index out of range for Flow' );
-			const curveLength = curve.getLength();
-			this.uniforms.spineLength.value = curveLength;
-			this.curveLengthArray[ index ] = curveLength;
-			this.curveArray[ index ] = curve;
-			updateSplineTexture( this.splineTexure, curve, index );
-
-		}
-		moveAlongCurve( amount ) {
-
-			this.uniforms.pathOffset.value += amount;
-
-		}
-
-	}
-	const matrix = new THREE.Matrix4();
-
-	/**
- * A helper class for creating instanced versions of flow, where the instances are placed on the curve.
- */
-	class InstancedFlow extends Flow {
-
-		/**
-   *
-   * @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 ) {
-
-			const mesh = new THREE.InstancedMesh( geometry, material, count );
-			mesh.instanceMatrix.setUsage( THREE.DynamicDrawUsage );
-			super( mesh, curveCount );
-			this.offsets = new Array( count ).fill( 0 );
-			this.whichCurve = new Array( count ).fill( 0 );
-
-		}
-
-		/**
-   * 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
-   */
-		writeChanges( index ) {
-
-			matrix.makeTranslation( this.curveLengthArray[ this.whichCurve[ index ] ], this.whichCurve[ index ], this.offsets[ index ] );
-			this.object3D.setMatrixAt( index, matrix );
-			this.object3D.instanceMatrix.needsUpdate = true;
-
-		}
-
-		/**
-   * 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
-   */
-		moveIndividualAlongCurve( index, offset ) {
-
-			this.offsets[ index ] += offset;
-			this.writeChanges( index );
-
-		}
-
-		/**
-   * 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
-   */
-		setCurve( index, curveNo ) {
-
-			if ( isNaN( curveNo ) ) throw Error( 'curve index being set is Not a Number (NaN)' );
-			this.whichCurve[ index ] = curveNo;
-			this.writeChanges( index );
-
-		}
-
-	}
-
-	THREE.Flow = Flow;
-	THREE.InstancedFlow = InstancedFlow;
-	THREE.getUniforms = getUniforms;
-	THREE.initSplineTexture = initSplineTexture;
-	THREE.modifyShader = modifyShader;
-	THREE.updateSplineTexture = updateSplineTexture;
-
-} )();

package/examples/js/modifiers/EdgeSplitModifier.js

@@ -1,228 +0,0 @@
-( function () {
-
-	const _A = new THREE.Vector3();
-	const _B = new THREE.Vector3();
-	const _C = new THREE.Vector3();
-	class EdgeSplitModifier {
-
-		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 = THREE.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 THREE.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 THREE.BufferGeometry();
-			geometry.setIndex( new THREE.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;
-
-		}
-
-	}
-
-	THREE.EdgeSplitModifier = EdgeSplitModifier;
-
-} )();