super-three 0.181.0 → 0.185.0

package/examples/jsm/exporters/PLYExporter.js

@@ -63,17 +63,30 @@ class PLYExporter {
 		const defaultOptions = {
 			binary: false,
 			excludeAttributes: [], // normal, uv, color, index
-			littleEndian: false
+			littleEndian: false,
+			customPropertyMapping: {}
 		};
 
 		options = Object.assign( defaultOptions, options );
 
 		const excludeAttributes = options.excludeAttributes;
+		const customPropertyMapping = options.customPropertyMapping;
+		const customAttributeNames = Object.keys( customPropertyMapping );
 		let includeIndices = true;
 		let includeNormals = false;
 		let includeColors = false;
 		let includeUVs = false;
 
+		// derive types from the attribtue's typed array (the exporter assumes
+		// all attributes of the same group e.g. "position" share the same data type)
+		let positionType = 'float';
+		let normalType = 'float';
+		let uvType = 'float';
+		let colorType = 'uchar';
+
+		const customTypes = {};
+		for ( const name of customAttributeNames ) customTypes[ name ] = 'float';
+
 		// count the vertices, check which properties are used,
 		// and cache the BufferGeometry
 		let vertexCount = 0;
@@ -101,11 +114,35 @@ class PLYExporter {
 				vertexCount += vertices.count;
 				faceCount += indices ? indices.count / 3 : vertices.count / 3;
 
-				if ( normals !== undefined ) includeNormals = true;
+				positionType = getPlyType( vertices.array );
+
+				if ( normals !== undefined ) {
+
+					includeNormals = true;
+					normalType = getPlyType( normals.array );
+
+				}
+
+				if ( uvs !== undefined ) {
+
+					includeUVs = true;
+					uvType = getPlyType( uvs.array );
+
+				}
+
+				if ( colors !== undefined ) {
+
+					includeColors = true;
+					colorType = getPlyType( colors.array );
 
-				if ( uvs !== undefined ) includeUVs = true;
+				}
+
+				for ( const name of customAttributeNames ) {
+
+					const attr = geometry.getAttribute( name );
+					if ( attr !== undefined ) customTypes[ name ] = getPlyType( attr.array );
 
-				if ( colors !== undefined ) includeColors = true;
+				}
 
 			} else if ( child.isPoints ) {
 
@@ -118,9 +155,28 @@ class PLYExporter {
 
 				vertexCount += vertices.count;
 
-				if ( normals !== undefined ) includeNormals = true;
+				positionType = getPlyType( vertices.array );
+
+				if ( normals !== undefined ) {
+
+					includeNormals = true;
+					normalType = getPlyType( normals.array );
+
+				}
+
+				if ( colors !== undefined ) {
+
+					includeColors = true;
+					colorType = getPlyType( colors.array );
+
+				}
+
+				for ( const name of customAttributeNames ) {
+
+					const attr = geometry.getAttribute( name );
+					if ( attr !== undefined ) customTypes[ name ] = getPlyType( attr.array );
 
-				if ( colors !== undefined ) includeColors = true;
+				}
 
 				includeIndices = false;
 
@@ -159,17 +215,17 @@ class PLYExporter {
 			`element vertex ${vertexCount}\n` +
 
 			// position
-			'property float x\n' +
-			'property float y\n' +
-			'property float z\n';
+			`property ${positionType} x\n` +
+			`property ${positionType} y\n` +
+			`property ${positionType} z\n`;
 
 		if ( includeNormals === true ) {
 
 			// normal
 			header +=
-				'property float nx\n' +
-				'property float ny\n' +
-				'property float nz\n';
+				`property ${normalType} nx\n` +
+				`property ${normalType} ny\n` +
+				`property ${normalType} nz\n`;
 
 		}
 
@@ -177,8 +233,8 @@ class PLYExporter {
 
 			// uvs
 			header +=
-				'property float s\n' +
-				'property float t\n';
+				`property ${uvType} s\n` +
+				`property ${uvType} t\n`;
 
 		}
 
@@ -186,9 +242,22 @@ class PLYExporter {
 
 			// colors
 			header +=
-				'property uchar red\n' +
-				'property uchar green\n' +
-				'property uchar blue\n';
+				`property ${colorType} red\n` +
+				`property ${colorType} green\n` +
+				`property ${colorType} blue\n`;
+
+		}
+
+		// custom attributes
+
+		for ( const name of customAttributeNames ) {
+
+			const type = customTypes[ name ];
+			for ( const propName of customPropertyMapping[ name ] ) {
+
+				header += `property ${type} ${propName}\n`;
+
+			}
 
 		}
 
@@ -214,11 +283,34 @@ class PLYExporter {
 			// Binary File Generation
 			const headerBin = new TextEncoder().encode( header );
 
-			// 3 position values at 4 bytes
-			// 3 normal values at 4 bytes
-			// 3 color channels with 1 byte
-			// 2 uv values at 4 bytes
-			const vertexListLength = vertexCount * ( 4 * 3 + ( includeNormals ? 4 * 3 : 0 ) + ( includeColors ? 3 : 0 ) + ( includeUVs ? 4 * 2 : 0 ) );
+			const posWriter = getBinaryWriter( positionType );
+			const normalWriter = includeNormals ? getBinaryWriter( normalType ) : null;
+			const uvWriter = includeUVs ? getBinaryWriter( uvType ) : null;
+			const colorWriter = includeColors ? getBinaryWriter( colorType ) : null;
+			const colorIsFloat = isFloatType( colorType );
+			const colorScale = getColorScale( colorType );
+
+			const customWriters = {};
+			const customIsFloat = {};
+			let customStride = 0;
+
+			for ( const name of customAttributeNames ) {
+
+				const type = customTypes[ name ];
+				const writer = getBinaryWriter( type );
+				customWriters[ name ] = writer;
+				customIsFloat[ name ] = isFloatType( type );
+				customStride += customPropertyMapping[ name ].length * writer.size;
+
+			}
+
+			const vertexListLength = vertexCount * (
+				3 * posWriter.size +
+				( includeNormals ? 3 * normalWriter.size : 0 ) +
+				( includeUVs ? 2 * uvWriter.size : 0 ) +
+				( includeColors ? 3 * colorWriter.size : 0 ) +
+				customStride
+			);
 
 			// 1 byte shape descriptor
 			// 3 vertex indices at ${indexByteCount} bytes
@@ -248,14 +340,14 @@ class PLYExporter {
 
 
 					// Position information
-					output.setFloat32( vOffset, vertex.x, options.littleEndian );
-					vOffset += 4;
+					posWriter.write( output, vOffset, vertex.x, options.littleEndian );
+					vOffset += posWriter.size;
 
-					output.setFloat32( vOffset, vertex.y, options.littleEndian );
-					vOffset += 4;
+					posWriter.write( output, vOffset, vertex.y, options.littleEndian );
+					vOffset += posWriter.size;
 
-					output.setFloat32( vOffset, vertex.z, options.littleEndian );
-					vOffset += 4;
+					posWriter.write( output, vOffset, vertex.z, options.littleEndian );
+					vOffset += posWriter.size;
 
 					// Normal information
 					if ( includeNormals === true ) {
@@ -266,25 +358,25 @@ class PLYExporter {
 
 							vertex.applyMatrix3( normalMatrixWorld ).normalize();
 
-							output.setFloat32( vOffset, vertex.x, options.littleEndian );
-							vOffset += 4;
+							normalWriter.write( output, vOffset, vertex.x, options.littleEndian );
+							vOffset += normalWriter.size;
 
-							output.setFloat32( vOffset, vertex.y, options.littleEndian );
-							vOffset += 4;
+							normalWriter.write( output, vOffset, vertex.y, options.littleEndian );
+							vOffset += normalWriter.size;
 
-							output.setFloat32( vOffset, vertex.z, options.littleEndian );
-							vOffset += 4;
+							normalWriter.write( output, vOffset, vertex.z, options.littleEndian );
+							vOffset += normalWriter.size;
 
 						} else {
 
-							output.setFloat32( vOffset, 0, options.littleEndian );
-							vOffset += 4;
+							normalWriter.write( output, vOffset, 0, options.littleEndian );
+							vOffset += normalWriter.size;
 
-							output.setFloat32( vOffset, 0, options.littleEndian );
-							vOffset += 4;
+							normalWriter.write( output, vOffset, 0, options.littleEndian );
+							vOffset += normalWriter.size;
 
-							output.setFloat32( vOffset, 0, options.littleEndian );
-							vOffset += 4;
+							normalWriter.write( output, vOffset, 0, options.littleEndian );
+							vOffset += normalWriter.size;
 
 						}
 
@@ -295,19 +387,19 @@ class PLYExporter {
 
 						if ( uvs != null ) {
 
-							output.setFloat32( vOffset, uvs.getX( i ), options.littleEndian );
-							vOffset += 4;
+							uvWriter.write( output, vOffset, uvs.getX( i ), options.littleEndian );
+							vOffset += uvWriter.size;
 
-							output.setFloat32( vOffset, uvs.getY( i ), options.littleEndian );
-							vOffset += 4;
+							uvWriter.write( output, vOffset, uvs.getY( i ), options.littleEndian );
+							vOffset += uvWriter.size;
 
 						} else {
 
-							output.setFloat32( vOffset, 0, options.littleEndian );
-							vOffset += 4;
+							uvWriter.write( output, vOffset, 0, options.littleEndian );
+							vOffset += uvWriter.size;
 
-							output.setFloat32( vOffset, 0, options.littleEndian );
-							vOffset += 4;
+							uvWriter.write( output, vOffset, 0, options.littleEndian );
+							vOffset += uvWriter.size;
 
 						}
 
@@ -322,25 +414,50 @@ class PLYExporter {
 
 							ColorManagement.workingToColorSpace( tempColor, SRGBColorSpace );
 
-							output.setUint8( vOffset, Math.floor( tempColor.r * 255 ) );
-							vOffset += 1;
+							const r = colorIsFloat ? tempColor.r : Math.round( tempColor.r * colorScale );
+							const g = colorIsFloat ? tempColor.g : Math.round( tempColor.g * colorScale );
+							const b = colorIsFloat ? tempColor.b : Math.round( tempColor.b * colorScale );
 
-							output.setUint8( vOffset, Math.floor( tempColor.g * 255 ) );
-							vOffset += 1;
+							colorWriter.write( output, vOffset, r, options.littleEndian );
+							vOffset += colorWriter.size;
 
-							output.setUint8( vOffset, Math.floor( tempColor.b * 255 ) );
-							vOffset += 1;
+							colorWriter.write( output, vOffset, g, options.littleEndian );
+							vOffset += colorWriter.size;
+
+							colorWriter.write( output, vOffset, b, options.littleEndian );
+							vOffset += colorWriter.size;
 
 						} else {
 
-							output.setUint8( vOffset, 255 );
-							vOffset += 1;
+							const white = colorIsFloat ? 1 : colorScale;
+
+							colorWriter.write( output, vOffset, white, options.littleEndian );
+							vOffset += colorWriter.size;
+
+							colorWriter.write( output, vOffset, white, options.littleEndian );
+							vOffset += colorWriter.size;
+
+							colorWriter.write( output, vOffset, white, options.littleEndian );
+							vOffset += colorWriter.size;
+
+						}
+
+					}
+
+					// Custom attributes
 
-							output.setUint8( vOffset, 255 );
-							vOffset += 1;
+					for ( const name of customAttributeNames ) {
 
-							output.setUint8( vOffset, 255 );
-							vOffset += 1;
+						const writer = customWriters[ name ];
+						const propCount = customPropertyMapping[ name ].length;
+						const attr = geometry.getAttribute( name );
+						const isFloat = customIsFloat[ name ];
+
+						for ( let c = 0; c < propCount; c ++ ) {
+
+							const raw = attr != null ? getAttributeComponent( attr, i, c ) : 0;
+							writer.write( output, vOffset, isFloat ? raw : Math.round( raw ), options.littleEndian );
+							vOffset += writer.size;
 
 						}
 
@@ -409,6 +526,17 @@ class PLYExporter {
 			let vertexList = '';
 			let faceList = '';
 
+			const positionIsFloat = isFloatType( positionType );
+			const normalIsFloat = isFloatType( normalType );
+			const uvIsFloat = isFloatType( uvType );
+			const colorIsFloat = isFloatType( colorType );
+			const colorScale = getColorScale( colorType );
+
+			const customIsFloat = {};
+			for ( const name of customAttributeNames ) customIsFloat[ name ] = isFloatType( customTypes[ name ] );
+
+			const encode = ( v, isFloat ) => isFloat ? v : Math.round( v );
+
 			traverseMeshes( function ( mesh, geometry ) {
 
 				const vertices = geometry.getAttribute( 'position' );
@@ -429,9 +557,9 @@ class PLYExporter {
 
 					// Position information
 					let line =
-						vertex.x + ' ' +
-						vertex.y + ' ' +
-						vertex.z;
+						encode( vertex.x, positionIsFloat ) + ' ' +
+						encode( vertex.y, positionIsFloat ) + ' ' +
+						encode( vertex.z, positionIsFloat );
 
 					// Normal information
 					if ( includeNormals === true ) {
@@ -443,9 +571,9 @@ class PLYExporter {
 							vertex.applyMatrix3( normalMatrixWorld ).normalize();
 
 							line += ' ' +
-								vertex.x + ' ' +
-								vertex.y + ' ' +
-								vertex.z;
+								encode( vertex.x, normalIsFloat ) + ' ' +
+								encode( vertex.y, normalIsFloat ) + ' ' +
+								encode( vertex.z, normalIsFloat );
 
 						} else {
 
@@ -461,8 +589,8 @@ class PLYExporter {
 						if ( uvs != null ) {
 
 							line += ' ' +
-								uvs.getX( i ) + ' ' +
-								uvs.getY( i );
+								encode( uvs.getX( i ), uvIsFloat ) + ' ' +
+								encode( uvs.getY( i ), uvIsFloat );
 
 						} else {
 
@@ -481,14 +609,33 @@ class PLYExporter {
 
 							ColorManagement.workingToColorSpace( tempColor, SRGBColorSpace );
 
-							line += ' ' +
-								Math.floor( tempColor.r * 255 ) + ' ' +
-								Math.floor( tempColor.g * 255 ) + ' ' +
-								Math.floor( tempColor.b * 255 );
+							const r = colorIsFloat ? tempColor.r : Math.round( tempColor.r * colorScale );
+							const g = colorIsFloat ? tempColor.g : Math.round( tempColor.g * colorScale );
+							const b = colorIsFloat ? tempColor.b : Math.round( tempColor.b * colorScale );
+
+							line += ` ${r} ${g} ${b}`;
 
 						} else {
 
-							line += ' 255 255 255';
+							const white = colorIsFloat ? 1 : colorScale;
+							line += ` ${white} ${white} ${white}`;
+
+						}
+
+					}
+
+					// Custom attributes
+
+					for ( const name of customAttributeNames ) {
+
+						const propCount = customPropertyMapping[ name ].length;
+						const attr = geometry.getAttribute( name );
+						const isFloat = customIsFloat[ name ];
+
+						for ( let c = 0; c < propCount; c ++ ) {
+
+							const raw = attr != null ? getAttributeComponent( attr, i, c ) : 0;
+							line += ' ' + encode( raw, isFloat );
 
 						}
 
@@ -541,6 +688,68 @@ class PLYExporter {
 
 }
 
+function getPlyType( array ) {
+
+	if ( array instanceof Int8Array ) return 'char';
+	if ( array instanceof Uint8Array || array instanceof Uint8ClampedArray ) return 'uchar';
+	if ( array instanceof Int16Array ) return 'short';
+	if ( array instanceof Uint16Array ) return 'ushort';
+	if ( array instanceof Int32Array ) return 'int';
+	if ( array instanceof Uint32Array ) return 'uint';
+	if ( array instanceof Float32Array ) return 'float';
+	if ( array instanceof Float64Array ) return 'double';
+	return 'float';
+
+}
+
+function getBinaryWriter( type ) {
+
+	switch ( type ) {
+
+		case 'char':	return { write: ( dv, at, v ) => dv.setInt8( at, v ), size: 1 };
+		case 'uchar':	return { write: ( dv, at, v ) => dv.setUint8( at, v ), size: 1 };
+		case 'short':	return { write: ( dv, at, v, le ) => dv.setInt16( at, v, le ), size: 2 };
+		case 'ushort':	return { write: ( dv, at, v, le ) => dv.setUint16( at, v, le ), size: 2 };
+		case 'int':		return { write: ( dv, at, v, le ) => dv.setInt32( at, v, le ), size: 4 };
+		case 'uint':	return { write: ( dv, at, v, le ) => dv.setUint32( at, v, le ), size: 4 };
+		case 'float':	return { write: ( dv, at, v, le ) => dv.setFloat32( at, v, le ), size: 4 };
+		case 'double':	return { write: ( dv, at, v, le ) => dv.setFloat64( at, v, le ), size: 8 };
+
+	}
+
+}
+
+function isFloatType( type ) {
+
+	return type === 'float' || type === 'double';
+
+}
+
+function getAttributeComponent( attr, i, c ) {
+
+	switch ( c ) {
+
+		case 0: return attr.getX( i );
+		case 1: return attr.getY( i );
+		case 2: return attr.getZ( i );
+		case 3: return attr.getW( i );
+
+	}
+
+}
+
+function getColorScale( type ) {
+
+	switch ( type ) {
+
+		case 'uchar':	return 255;
+		case 'ushort':	return 65535;
+		default:		return 1;
+
+	}
+
+}
+
 /**
  * Export options of `PLYExporter`.
  *
@@ -550,6 +759,10 @@ class PLYExporter {
  * the exported PLY file. Valid values are `'color'`, `'normal'`, `'uv'`, and `'index'`. If triangle
  * indices are excluded, then a point cloud is exported.
  * @property {boolean} [littleEndian=false] - Whether the binary export uses little or big endian.
+ * @property {Object<string, Array<string>>} [customPropertyMapping] - A mapping that allows
+ * exporting custom buffer attributes as PLY vertex properties. Each entry maps a buffer attribute
+ * name to an array of PLY property names. The number of property names must match the item size
+ * of the buffer attribute. This is the inverse of `PLYLoader.setCustomPropertyNameMapping()`.
  **/
 
 /**