@needle-tools/three 0.169.20 → 0.183.2-canary.0

package/examples/jsm/loaders/VRMLLoader.js

@@ -18,10 +18,13 @@ import {
 	LineSegments,
 	Loader,
 	LoaderUtils,
+	MathUtils,
 	Mesh,
 	MeshBasicMaterial,
 	MeshPhongMaterial,
 	Object3D,
+	OrthographicCamera,
+	PerspectiveCamera,
 	Points,
 	PointsMaterial,
 	Quaternion,
@@ -36,15 +39,40 @@ import {
 } from 'three';
 import chevrotain from '../libs/chevrotain.module.min.js';
 
-
+/**
+ * A loader for the VRML format.
+ *
+ * ```js
+ * const loader = new VRMLLoader();
+ * const object = await loader.loadAsync( 'models/vrml/house.wrl' );
+ * scene.add( object );
+ * ```
+ *
+ * @augments Loader
+ * @three_import import { VRMLLoader } from 'three/addons/loaders/VRMLLoader.js';
+ */
 class VRMLLoader extends Loader {
 
+	/**
+	 * Constructs a new VRML loader.
+	 *
+	 * @param {LoadingManager} [manager] - The loading manager.
+	 */
 	constructor( manager ) {
 
 		super( manager );
 
 	}
 
+	/**
+	 * Starts loading from the given URL and passes the loaded VRML asset
+	 * to the `onLoad()` callback.
+	 *
+	 * @param {string} url - The path/URL of the file to be loaded. This can also be a data URI.
+	 * @param {function(Scene)} onLoad - Executed when the loading process has been finished.
+	 * @param {onProgressCallback} onProgress - Executed while the loading is in progress.
+	 * @param {onErrorCallback} onError - Executed when errors occur.
+	 */
 	load( url, onLoad, onProgress, onError ) {
 
 		const scope = this;
@@ -81,6 +109,13 @@ class VRMLLoader extends Loader {
 
 	}
 
+	/**
+	 * Parses the given VRML data and returns the resulting scene.
+	 *
+	 * @param {string} data - The raw VRML data as a string.
+	 * @param {string} path - The URL base path.
+	 * @return {Scene} The parsed scene.
+	 */
 	parse( data, path ) {
 
 		const nodeMap = {};
@@ -134,6 +169,7 @@ class VRMLLoader extends Loader {
 			const nodeTypes = [
 				'Anchor', 'Billboard', 'Collision', 'Group', 'Transform', // grouping nodes
 				'Inline', 'LOD', 'Switch', // special groups
+				'PerspectiveCamera', 'OrthographicCamera',
 				'AudioClip', 'DirectionalLight', 'PointLight', 'Script', 'Shape', 'Sound', 'SpotLight', 'WorldInfo', // common nodes
 				'CylinderSensor', 'PlaneSensor', 'ProximitySensor', 'SphereSensor', 'TimeSensor', 'TouchSensor', 'VisibilitySensor', // sensors
 				'Box', 'Cone', 'Cylinder', 'ElevationGrid', 'Extrusion', 'IndexedFaceSet', 'IndexedLineSet', 'PointSet', 'Sphere', // geometries
@@ -250,7 +286,7 @@ class VRMLLoader extends Loader {
 
 		function createVisitor( BaseVRMLVisitor ) {
 
-			// the visitor is created dynmaically based on the given base class
+			// the visitor is created dynamically based on the given base class
 
 			class VRMLToASTVisitor extends BaseVRMLVisitor {
 
@@ -701,6 +737,11 @@ class VRMLLoader extends Loader {
 					build = buildWorldInfoNode( node );
 					break;
 
+				case 'OrthographicCamera':
+				case 'PerspectiveCamera':
+					build = buildCamera( node, nodeName );
+					break;
+
 				case 'Billboard':
 
 				case 'Inline':
@@ -1556,6 +1597,74 @@ class VRMLLoader extends Loader {
 
 		}
 
+		function buildCamera( node, type ) {
+
+			const camera = ( type === 'PerspectiveCamera' ) ? new PerspectiveCamera() : new OrthographicCamera();
+
+			const width = ( typeof window !== 'undefined' ) ? window.innerWidth : 1;
+			const height = ( typeof window !== 'undefined' ) ? window.innerHeight : 1;
+			const aspect = width / height;
+
+			const fields = node.fields;
+
+			for ( let i = 0, l = fields.length; i < l; i ++ ) {
+
+				const field = fields[ i ];
+				const fieldName = field.name;
+				const fieldValues = field.values;
+
+				switch ( fieldName ) {
+
+					case 'position':
+						camera.position.set( fieldValues[ 0 ], fieldValues[ 1 ], fieldValues[ 0 ] );
+						break;
+
+					case 'orientation':
+						const axis = new Vector3( fieldValues[ 0 ], fieldValues[ 1 ], fieldValues[ 2 ] ).normalize();
+						const angle = fieldValues[ 3 ];
+						camera.quaternion.setFromAxisAngle( axis, angle );
+						break;
+
+					case 'focalDistance':
+						camera.userData.focalDistance = fieldValues[ 0 ]; // might be useful for DoF
+						break;
+
+					case 'heightAngle':
+
+						// for perspective cams only
+
+						camera.fov = MathUtils.radToDeg( fieldValues[ 0 ] );
+						camera.aspect = aspect;
+						camera.updateProjectionMatrix();
+
+						break;
+
+					case 'height':
+
+						// for ortho cams only
+
+						const halfHeight = fieldValues[ 0 ] / 2;
+						const halfWidth = halfHeight * aspect;
+
+						camera.left = - halfWidth;
+						camera.right = halfWidth;
+						camera.top = halfHeight;
+						camera.bottom = - halfHeight;
+						camera.updateProjectionMatrix();
+						break;
+
+					default:
+						console.warn( 'THREE.VRMLLoader: Unknown field:', fieldName );
+						break;
+
+				}
+
+			}
+
+			return camera;
+
+		}
+
 		function buildIndexedFaceSetNode( node ) {
 
 			let color, coord, normal, texCoord;
@@ -1890,7 +1999,7 @@ class VRMLLoader extends Loader {
 
 						// if the colorIndex field is not empty, then one color is used for each polyline of the IndexedLineSet.
 
-						const expandedColorIndex = expandLineIndex( colorIndex ); // compute colors for each line segment (rendering primitve)
+						const expandedColorIndex = expandLineIndex( colorIndex ); // compute colors for each line segment (rendering primitive)
 						colorAttribute = computeAttributeFromIndexedData( expandedLineIndex, expandedColorIndex, color, 3 ); // compute data on vertex level
 
 					} else {
@@ -1907,8 +2016,8 @@ class VRMLLoader extends Loader {
 
 						// if the colorIndex field is not empty, then colors are applied to each vertex of the IndexedLineSet
 
-						const flattenLineColors = flattenData( color, colorIndex ); // compute colors for each VRML primitve
-						const expandedLineColors = expandLineData( flattenLineColors, coordIndex ); // compute colors for each line segment (rendering primitve)
+						const flattenLineColors = flattenData( color, colorIndex ); // compute colors for each VRML primitive
+						const expandedLineColors = expandLineData( flattenLineColors, coordIndex ); // compute colors for each line segment (rendering primitive)
 						colorAttribute = computeAttributeFromLineData( expandedLineIndex, expandedLineColors ); // compute data on vertex level
 
 
@@ -1916,7 +2025,7 @@ class VRMLLoader extends Loader {
 
 						// if the colorIndex field is empty, then the coordIndex field is used to choose colors from the Color node
 
-						const expandedLineColors = expandLineData( color, coordIndex ); // compute colors for each line segment (rendering primitve)
+						const expandedLineColors = expandLineData( color, coordIndex ); // compute colors for each line segment (rendering primitive)
 						colorAttribute = computeAttributeFromLineData( expandedLineIndex, expandedLineColors ); // compute data on vertex level
 
 					}
@@ -2748,7 +2857,7 @@ class VRMLLoader extends Loader {
 
 			const indices = [];
 
-			// since face defintions can have more than three vertices, it's necessary to
+			// since face definitions can have more than three vertices, it's necessary to
 			// perform a simple triangulation
 
 			let start = 0;
@@ -3109,7 +3218,7 @@ class VRMLLoader extends Loader {
 
 				color.fromBufferAttribute( attribute, i );
 
-				ColorManagement.toWorkingColorSpace( color, SRGBColorSpace );
+				ColorManagement.colorSpaceToWorking( color, SRGBColorSpace );
 
 				attribute.setXYZ( i, color.r, color.g, color.b );
 
@@ -3123,7 +3232,7 @@ class VRMLLoader extends Loader {
 		 * node, but could be applied to other nodes with multiple faces as well.
 		 *
 		 * When used with the Background node, default is directionIsDown is true if
-		 * interpolating the skyColor down from the Zenith. When interpolationg up from
+		 * interpolating the skyColor down from the Zenith. When interpolating up from
 		 * the Nadir i.e. interpolating the groundColor, the directionIsDown is false.
 		 *
 		 * The first angle is never specified, it is the Zenith (0 rad). Angles are specified
@@ -3135,8 +3244,8 @@ class VRMLLoader extends Loader {
 		 *
 		 * @param {BufferGeometry} geometry
 		 * @param {number} radius
-		 * @param {array} angles
-		 * @param {array} colors
+		 * @param {Array} angles
+		 * @param {Array} colors
 		 * @param {boolean} topDown - Whether to work top down or bottom up.
 		 */
 		function paintFaces( geometry, radius, angles, colors, topDown ) {
@@ -3216,7 +3325,7 @@ class VRMLLoader extends Loader {
 
 				color.copy( colorA ).lerp( colorB, t );
 
-				ColorManagement.toWorkingColorSpace( color, SRGBColorSpace );
+				ColorManagement.colorSpaceToWorking( color, SRGBColorSpace );
 
 				colorAttribute.setXYZ( index, color.r, color.g, color.b );
 

package/examples/jsm/loaders/VTKLoader.js

@@ -7,16 +7,49 @@ import {
 	Loader,
 	SRGBColorSpace
 } from 'three';
-import * as fflate from '../libs/fflate.module.js';
-
+import { unzlibSync } from '../libs/fflate.module.js';
+
+/**
+ * A loader for the VTK format.
+ *
+ * This loader only supports the `POLYDATA` dataset format so far. Other formats
+ * (structured points, structured grid, rectilinear grid, unstructured grid, appended)
+ * are not supported.
+ *
+ * ```js
+ * const loader = new VTKLoader();
+ * const geometry = await loader.loadAsync( 'models/vtk/liver.vtk' );
+ * geometry.computeVertexNormals();
+ *
+ * const mesh = new THREE.Mesh( geometry, new THREE.MeshLambertMaterial() );
+ * scene.add( mesh );
+ * ```
+ *
+ * @augments Loader
+ * @three_import import { VTKLoader } from 'three/addons/loaders/VTKLoader.js';
+ */
 class VTKLoader extends Loader {
 
+	/**
+	 * Constructs a new VTK loader.
+	 *
+	 * @param {LoadingManager} [manager] - The loading manager.
+	 */
 	constructor( manager ) {
 
 		super( manager );
 
 	}
 
+	/**
+	 * Starts loading from the given URL and passes the loaded VRML asset
+	 * to the `onLoad()` callback.
+	 *
+	 * @param {string} url - The path/URL of the file to be loaded. This can also be a data URI.
+	 * @param {function(BufferGeometry)} onLoad - Executed when the loading process has been finished.
+	 * @param {onProgressCallback} onProgress - Executed while the loading is in progress.
+	 * @param {onErrorCallback} onError - Executed when errors occur.
+	 */
 	load( url, onLoad, onProgress, onError ) {
 
 		const scope = this;
@@ -52,6 +85,12 @@ class VTKLoader extends Loader {
 
 	}
 
+	/**
+	 * Parses the given VTK data and returns the resulting geometry.
+	 *
+	 * @param {ArrayBuffer} data - The raw VTK data as an array buffer
+	 * @return {BufferGeometry} The parsed geometry.
+	 */
 	parse( data ) {
 
 		function parseASCII( data ) {
@@ -73,8 +112,20 @@ class VTKLoader extends Loader {
 			// pattern for detecting the end of a number sequence
 			const patWord = /^[^\d.\s-]+/;
 
-			// pattern for reading vertices, 3 floats or integers
-			const pat3Floats = /(\-?\d+\.?[\d\-\+e]*)\s+(\-?\d+\.?[\d\-\+e]*)\s+(\-?\d+\.?[\d\-\+e]*)/g;
+			function parseFloats( line ) {
+
+				const result = [];
+				const parts = line.split( /\s+/ );
+
+				for ( let i = 0; i < parts.length; i ++ ) {
+
+					if ( parts[ i ] !== '' ) result.push( parseFloat( parts[ i ] ) );
+
+				}
+
+				return result;
+
+			}
 
 			// pattern for connectivity, an integer followed by any number of ints
 			// the first integer is the number of polygon nodes
@@ -126,14 +177,15 @@ class VTKLoader extends Loader {
 				} else if ( inPointsSection ) {
 
 					// get the vertices
-					while ( ( result = pat3Floats.exec( line ) ) !== null ) {
+					if ( patWord.exec( line ) === null ) {
+
+						const values = parseFloats( line );
 
-						if ( patWord.exec( line ) !== null ) break;
+						for ( let k = 0; k + 2 < values.length; k += 3 ) {
 
-						const x = parseFloat( result[ 1 ] );
-						const y = parseFloat( result[ 2 ] );
-						const z = parseFloat( result[ 3 ] );
-						positions.push( x, y, z );
+							positions.push( values[ k ], values[ k + 1 ], values[ k + 2 ] );
+
+						}
 
 					}
 
@@ -204,17 +256,16 @@ class VTKLoader extends Loader {
 
 						// Get the colors
 
-						while ( ( result = pat3Floats.exec( line ) ) !== null ) {
+						if ( patWord.exec( line ) === null ) {
 
-							if ( patWord.exec( line ) !== null ) break;
+							const values = parseFloats( line );
 
-							const r = parseFloat( result[ 1 ] );
-							const g = parseFloat( result[ 2 ] );
-							const b = parseFloat( result[ 3 ] );
+							for ( let k = 0; k + 2 < values.length; k += 3 ) {
 
-							color.setRGB( r, g, b, SRGBColorSpace );
+								color.setRGB( values[ k ], values[ k + 1 ], values[ k + 2 ], SRGBColorSpace );
+								colors.push( color.r, color.g, color.b );
 
-							colors.push( color.r, color.g, color.b );
+							}
 
 						}
 
@@ -222,14 +273,15 @@ class VTKLoader extends Loader {
 
 						// Get the normal vectors
 
-						while ( ( result = pat3Floats.exec( line ) ) !== null ) {
+						if ( patWord.exec( line ) === null ) {
+
+							const values = parseFloats( line );
 
-							if ( patWord.exec( line ) !== null ) break;
+							for ( let k = 0; k + 2 < values.length; k += 3 ) {
 
-							const nx = parseFloat( result[ 1 ] );
-							const ny = parseFloat( result[ 2 ] );
-							const nz = parseFloat( result[ 3 ] );
-							normals.push( nx, ny, nz );
+								normals.push( values[ k ], values[ k + 1 ], values[ k + 2 ] );
+
+							}
 
 						}
 
@@ -361,7 +413,7 @@ class VTKLoader extends Loader {
 				let index = start;
 				let c = buffer[ index ];
 				const s = [];
-				while ( c !== 10 ) {
+				while ( c !== 10 && index < buffer.length ) {
 
 					s.push( String.fromCharCode( c ) );
 					index ++;
@@ -807,7 +859,7 @@ class VTKLoader extends Loader {
 
 					for ( let i = 0; i < dataOffsets.length - 1; i ++ ) {
 
-						const data = fflate.unzlibSync( byteData.slice( dataOffsets[ i ], dataOffsets[ i + 1 ] ) );
+						const data = unzlibSync( byteData.slice( dataOffsets[ i ], dataOffsets[ i + 1 ] ) );
 						content = data.buffer;
 
 						if ( ele.attributes.type === 'Float32' ) {

package/examples/jsm/loaders/XYZLoader.js

@@ -7,8 +7,38 @@ import {
 	SRGBColorSpace
 } from 'three';
 
+/**
+ * A loader for the XYZ format.
+ *
+ * XYZ is a very simple format for storing point clouds. The layouts
+ * `XYZ` (points) and `XYZRGB` (points + colors) are supported.
+ *
+ * ```js
+ * const loader = new XYZLoader();
+ * const geometry = await loader.loadAsync( 'models/xyz/helix_201.xyz' );
+ * geometry.center();
+ *
+ * const vertexColors = ( geometry.hasAttribute( 'color' ) === true );
+ * const material = new THREE.PointsMaterial( { size: 0.1, vertexColors: vertexColors } );
+ *
+ * const points = new THREE.Points( geometry, material );
+ * scene.add( points );
+ * ```
+ *
+ * @augments Loader
+ * @three_import import { XYZLoader } from 'three/addons/loaders/XYZLoader.js';
+ */
 class XYZLoader extends Loader {
 
+	/**
+	 * Starts loading from the given URL and passes the loaded XYZ asset
+	 * to the `onLoad()` callback.
+	 *
+	 * @param {string} url - The path/URL of the file to be loaded. This can also be a data URI.
+	 * @param {function(BufferGeometry)} onLoad - Executed when the loading process has been finished.
+	 * @param {onProgressCallback} onProgress - Executed while the loading is in progress.
+	 * @param {onErrorCallback} onError - Executed when errors occur.
+	 */
 	load( url, onLoad, onProgress, onError ) {
 
 		const scope = this;
@@ -43,6 +73,12 @@ class XYZLoader extends Loader {
 
 	}
 
+	/**
+	 * Parses the given XYZ data and returns the resulting geometry.
+	 *
+	 * @param {string} text - The raw XYZ data as a string.
+	 * @return {BufferGeometry} The geometry representing the point cloud.
+	 */
 	parse( text ) {
 
 		const lines = text.split( '\n' );