@gnsx/three 0.185.15 → 0.186.0

package/examples/jsm/loaders/3DMLoader.js

@@ -1,4 +1,6 @@
 import {
+	BufferAttribute,
+	BufferGeometry,
 	BufferGeometryLoader,
 	CanvasTexture,
 	ClampToEdgeWrapping,
@@ -30,6 +32,7 @@ import {
 import { EXRLoader } from '../loaders/EXRLoader.js';
 
 const _taskCache = new WeakMap();
+const _bufferGeometryLoader = new BufferGeometryLoader();
 
 /**
  * A loader for Rhinoceros 3D files and objects.
@@ -38,11 +41,11 @@ const _taskCache = new WeakMap();
  * animate, and translate NURBS curves, surfaces, breps, extrusions, point clouds,
  * as well as polygon meshes and SubD objects. `rhino3dm.js` is compiled to WebAssembly
  * from the open source geometry library `openNURBS`. The loader currently uses
- * `rhino3dm.js 8.4.0`.
+ * `rhino3dm.js 8.32.1`.
  *
  * ```js
  * const loader = new Rhino3dmLoader();
- * loader.setLibraryPath( 'https://cdn.jsdelivr.net/npm/rhino3dm@8.17.0/' );
+ * loader.setLibraryPath( 'https://cdn.jsdelivr.net/npm/rhino3dm@8.32.1/' );
  *
  * const object = await loader.loadAsync( 'models/3dm/Rhino_Logo.3dm' );
  * scene.add( object );
@@ -77,6 +80,10 @@ class Rhino3dmLoader extends Loader {
 		this.workerSourceURL = '';
 		this.workerConfig = {};
 
+		// Number of global subdivisions applied to SubD objects before meshing. Higher
+		// values increase smoothness at the cost of (potentially very large) vertex counts.
+		this.subdivisionLevel = 3;
+
 		this.materials = [];
 		this.warnings = [];
 
@@ -112,6 +119,22 @@ class Rhino3dmLoader extends Loader {
 
 	}
 
+	/**
+	 * Sets the number of global subdivisions applied to SubD objects before they are
+	 * meshed for display. The default is `3`. Large models with many SubD objects may
+	 * benefit from a lower value to keep vertex counts manageable.
+	 *
+	 * @param {number} level - The subdivision level.
+	 * @return {Rhino3dmLoader} A reference to this loader.
+	 */
+	setSubdivisionLevel( level ) {
+
+		this.subdivisionLevel = level;
+
+		return this;
+
+	}
+
 	/**
 	 * Starts loading from the given URL and passes the loaded 3DM asset
 	 * to the `onLoad()` callback.
@@ -189,9 +212,7 @@ class Rhino3dmLoader extends Loader {
 
 					worker._callbacks[ taskID ] = { resolve, reject };
 
-					worker.postMessage( { type: 'decode', id: taskID, buffer }, [ buffer ] );
-
-					// this.debug();
+					worker.postMessage( { type: 'decode', id: taskID, buffer, subdivisionLevel: this.subdivisionLevel }, [ buffer ] );
 
 				} );
 
@@ -213,7 +234,6 @@ class Rhino3dmLoader extends Loader {
 
 					this._releaseTask( worker, taskID );
 
-					//this.debug();
 
 				}
 
@@ -241,14 +261,24 @@ class Rhino3dmLoader extends Loader {
 	 */
 	parse( data, onLoad, onError ) {
 
-		this.decodeObjects( data, '' )
-			.then( result => {
+		this.parseAsync( data ).then( onLoad ).catch( onError );
 
-				result.userData.warnings = this.warnings;
-				onLoad( result );
+	}
 
-			} )
-			.catch( e => onError( e ) );
+	/**
+	 * Parses the given 3DM data and returns a Promise that resolves with the loaded asset.
+	 *
+	 * @param {ArrayBuffer} data - The raw 3DM asset data as an array buffer.
+	 * @return {Promise<Object3D>} A Promise that resolves with the decoded 3D object.
+	 */
+	parseAsync( data ) {
+
+		return this.decodeObjects( data, '' ).then( result => {
+
+			result.userData.warnings = this.warnings;
+			return result;
+
+		} );
 
 	}
 
@@ -304,19 +334,18 @@ class Rhino3dmLoader extends Loader {
 
 		}
 
-		//console.log(material)
 
 		const mat = new MeshPhysicalMaterial( {
 
 			color: new Color( material.diffuseColor.r / 255.0, material.diffuseColor.g / 255.0, material.diffuseColor.b / 255.0 ),
-			emissive: new Color( material.emissionColor.r, material.emissionColor.g, material.emissionColor.b ),
+			emissive: new Color( material.emissionColor.r / 255.0, material.emissionColor.g / 255.0, material.emissionColor.b / 255.0 ),
 			flatShading: material.disableLighting,
 			ior: material.indexOfRefraction,
 			name: material.name,
 			reflectivity: material.reflectivity,
 			opacity: 1.0 - material.transparency,
 			side: DoubleSide,
-			specularColor: material.specularColor,
+			specularColor: new Color( material.specularColor.r / 255.0, material.specularColor.g / 255.0, material.specularColor.b / 255.0 ),
 			transparent: material.transparency > 0 ? true : false
 
 		} );
@@ -333,20 +362,18 @@ class Rhino3dmLoader extends Loader {
 			mat.clearcoat = pbr.clearcoat;
 			mat.clearcoatRoughness = pbr.clearcoatRoughness;
 			mat.metalness = pbr.metallic;
-			mat.transmission = 1 - pbr.opacity;
 			mat.roughness = pbr.roughness;
 			mat.sheen = pbr.sheen;
 			mat.specularIntensity = pbr.specular;
 			mat.thickness = pbr.subsurface;
 
-		}
-
-		if ( material.pbrSupported && material.pbr.opacity === 0 && material.transparency === 1 ) {
-
-			//some compromises
-
-			mat.opacity = 0.2;
-			mat.transmission = 1.00;
+			// Rhino PBR Opacity is coverage/alpha, not glass transmission, and is
+			// 1 = opaque (glTF/Disney convention, matching three.js mat.opacity — unlike
+			// the legacy Material.transparency used above, which is 0 = opaque). Map it
+			// straight to opacity so it behaves as pure alpha; leave mat.transmission at
+			// its default (0) rather than deriving glass from opacity. (RH3DM-190)
+			mat.opacity = pbr.opacity;
+			mat.transparent = pbr.opacity < 1.0;
 
 		}
 
@@ -360,7 +387,6 @@ class Rhino3dmLoader extends Loader {
 
 				const map = textureLoader.load( texture.image );
 
-				//console.log(texture.type )
 
 				switch ( texture.type ) {
 
@@ -527,11 +553,13 @@ class Rhino3dmLoader extends Loader {
 		const instanceReferences = [];
 
 		object.userData[ 'layers' ] = data.layers;
+		object.userData[ 'views' ] = data.views;
+		object.userData[ 'namedViews' ] = data.namedViews;
 		object.userData[ 'groups' ] = data.groups;
+		object.userData[ 'strings' ] = data.strings;
 		object.userData[ 'settings' ] = data.settings;
 		object.userData.settings[ 'renderSettings' ] = data.renderSettings;
 		object.userData[ 'objectType' ] = 'File3dm';
-		object.userData[ 'materials' ] = null;
 
 		object.name = this.url;
 
@@ -677,15 +705,38 @@ class Rhino3dmLoader extends Loader {
 
 		}
 
-		object.userData[ 'materials' ] = this.materials;
 		object.name = '';
 		return object;
 
 	}
 
-	_createObject( obj, mat ) {
+	/**
+	 * Builds a BufferGeometry from a worker payload. Meshes decoded via the fast path
+	 * arrive as transferable typed arrays (`format: 'buffers'`) and are assembled directly;
+	 * everything else falls back to the three.js BufferGeometry JSON produced by
+	 * `toThreejsJSON()` (older rhino3dm, point clouds, curves, …).
+	 */
+	_geometryFromData( data ) {
+
+		if ( data && data.format === 'buffers' ) {
+
+			const geometry = new BufferGeometry();
+
+			if ( data.position && data.position.length ) geometry.setAttribute( 'position', new BufferAttribute( data.position, 3 ) );
+			if ( data.normal && data.normal.length ) geometry.setAttribute( 'normal', new BufferAttribute( data.normal, 3 ) );
+			if ( data.uv && data.uv.length ) geometry.setAttribute( 'uv', new BufferAttribute( data.uv, 2 ) );
+			if ( data.color && data.color.length ) geometry.setAttribute( 'color', new BufferAttribute( data.color, 3 ) );
+			if ( data.index && data.index.length ) geometry.setIndex( new BufferAttribute( data.index, 1 ) );
+
+			return geometry;
 
-		const loader = new BufferGeometryLoader();
+		}
+
+		return _bufferGeometryLoader.parse( data );
+
+	}
+
+	_createObject( obj, mat ) {
 
 		const attributes = obj.attributes;
 
@@ -696,7 +747,7 @@ class Rhino3dmLoader extends Loader {
 			case 'Point':
 			case 'PointSet':
 
-				geometry = loader.parse( obj.geometry );
+				geometry = this._geometryFromData( obj.geometry );
 
 				if ( geometry.hasAttribute( 'color' ) ) {
 
@@ -731,7 +782,7 @@ class Rhino3dmLoader extends Loader {
 
 				if ( obj.geometry === null ) return;
 
-				geometry = loader.parse( obj.geometry );
+				geometry = this._geometryFromData( obj.geometry );
 
 
 				if ( mat === null ) {
@@ -765,7 +816,7 @@ class Rhino3dmLoader extends Loader {
 
 			case 'Curve':
 
-				geometry = loader.parse( obj.geometry );
+				geometry = this._geometryFromData( obj.geometry );
 
 				_color = attributes.drawColor;
 				color = new Color( _color.r / 255.0, _color.g / 255.0, _color.b / 255.0 );
@@ -1088,16 +1139,20 @@ function Rhino3dmWorker() {
 
 				taskID = message.id;
 				const buffer = message.buffer;
+				const subdivisionLevel = message.subdivisionLevel;
 				libraryPending.then( () => {
 
 					try {
 
-						const data = decodeObjects( rhino, buffer );
-						self.postMessage( { type: 'decode', id: message.id, data } );
+						const data = decodeObjects( rhino, buffer, subdivisionLevel );
+						// Transfer the mesh typed arrays (fast path) instead of structure-cloning
+						// them across the worker boundary.
+						self.postMessage( { type: 'decode', id: message.id, data }, collectTransferables( data ) );
 
 					} catch ( error ) {
 
-						self.postMessage( { type: 'error', id: message.id, error } );
+						// Error objects don't always survive structured clone with their stack intact.
+						self.postMessage( { type: 'error', id: message.id, error: { message: error.message, stack: error.stack } } );
 
 					}
 
@@ -1109,7 +1164,59 @@ function Rhino3dmWorker() {
 
 	};
 
-	function decodeObjects( rhino, buffer ) {
+	// Converts a rhino3dm mesh or point cloud to a Three.js payload. When the wasm build
+	// supports toThreejsBuffers (rhino3dm >= 8.32.1 for point clouds, >= 8.32 for meshes),
+	// returns transferable typed arrays tagged `format: 'buffers'`; otherwise falls back to
+	// the element-by-element BufferGeometry JSON.
+	function meshToThreejs( geom ) {
+
+		if ( typeof geom.toThreejsBuffers === 'function' ) {
+
+			const b = geom.toThreejsBuffers( false );
+			const g = { format: 'buffers', position: b.position };
+			if ( b.normal ) g.normal = b.normal; // meshes always have normals; point clouds may not
+			if ( b.index ) g.index = b.index; // meshes only (point clouds are non-indexed)
+			if ( b.uv ) g.uv = b.uv;
+			if ( b.color ) g.color = b.color;
+			return g;
+
+		}
+
+		return geom.toThreejsJSON();
+
+	}
+
+	// Gathers the ArrayBuffers backing every fast-path mesh so postMessage can transfer
+	// (move) them to the main thread instead of copying.
+	function collectTransferables( data ) {
+
+		const transfer = new Set();
+
+		if ( data && data.objects ) {
+
+			for ( const obj of data.objects ) {
+
+				const g = obj.geometry;
+
+				if ( g && g.format === 'buffers' ) {
+
+					for ( const key of [ 'position', 'normal', 'uv', 'color', 'index' ] ) {
+
+						if ( g[ key ] && g[ key ].buffer ) transfer.add( g[ key ].buffer );
+
+					}
+
+				}
+
+			}
+
+		}
+
+		return Array.from( transfer );
+
+	}
+
+	function decodeObjects( rhino, buffer, subdivisionLevel ) {
 
 		const arr = new Uint8Array( buffer );
 		const doc = rhino.File3dm.fromByteArray( arr );
@@ -1131,7 +1238,7 @@ function Rhino3dmWorker() {
 
 			const _object = objs.get( i );
 
-			const object = extractObjectData( _object, doc );
+			const object = extractObjectData( _object, doc, subdivisionLevel );
 
 			_object.delete();
 
@@ -1144,7 +1251,6 @@ function Rhino3dmWorker() {
 		}
 
 		// Handle instance definitions
-		// console.log( `Instance Definitions Count: ${doc.instanceDefinitions().count()}` );
 
 		for ( let i = 0; i < doc.instanceDefinitions().count; i ++ ) {
 
@@ -1276,15 +1382,11 @@ function Rhino3dmWorker() {
 		//TODO: Handle other document stuff like dimstyles, instance definitions, bitmaps etc.
 
 		// Handle dimstyles
-		// console.log( `Dimstyle Count: ${doc.dimstyles().count()}` );
 
 		// Handle bitmaps
-		// console.log( `Bitmap Count: ${doc.bitmaps().count()}` );
 
 		// Handle strings
-		// console.log( `Document Strings Count: ${doc.strings().count()}` );
 		// Note: doc.strings().documentUserTextCount() counts any doc.strings defined in a section
-		// console.log( `Document User Text Count: ${doc.strings().documentUserTextCount()}` );
 
 		const strings_count = doc.strings().count;
 
@@ -1437,7 +1539,7 @@ function Rhino3dmWorker() {
 
 	}
 
-	function extractObjectData( object, doc ) {
+	function extractObjectData( object, doc, subdivisionLevel ) {
 
 		const _geometry = object.geometry();
 		const _attributes = object.attributes();
@@ -1507,7 +1609,7 @@ function Rhino3dmWorker() {
 			case rhino.ObjectType.PointSet:
 			case rhino.ObjectType.Mesh:
 
-				geometry = _geometry.toThreejsJSON();
+				geometry = meshToThreejs( _geometry );
 
 				break;
 
@@ -1535,7 +1637,7 @@ function Rhino3dmWorker() {
 				if ( mesh.faces().count > 0 ) {
 
 					mesh.compact();
-					geometry = mesh.toThreejsJSON();
+					geometry = meshToThreejs( mesh );
 					faces.delete();
 
 				}
@@ -1550,7 +1652,7 @@ function Rhino3dmWorker() {
 
 				if ( mesh ) {
 
-					geometry = mesh.toThreejsJSON();
+					geometry = meshToThreejs( mesh );
 					mesh.delete();
 
 				}
@@ -1592,11 +1694,11 @@ function Rhino3dmWorker() {
 			case rhino.ObjectType.SubD:
 
 				// TODO: precalculate resulting vertices and faces and warn on excessive results
-				_geometry.subdivide( 3 );
+				_geometry.subdivide( subdivisionLevel );
 				mesh = rhino.Mesh.createFromSubDControlNet( _geometry, false );
 				if ( mesh ) {
 
-					geometry = mesh.toThreejsJSON();
+					geometry = meshToThreejs( mesh );
 					mesh.delete();
 
 				}
@@ -1706,7 +1808,6 @@ function Rhino3dmWorker() {
 			} else {
 
 				// these are functions that could be called to extract more data.
-				//console.log( `${property}: ${object[ property ].constructor.name}` );
 
 			}
 

package/examples/jsm/loaders/3MFLoader.js

@@ -3,6 +3,7 @@ import {
 	BufferGeometry,
 	ClampToEdgeWrapping,
 	Color,
+	CylinderGeometry,
 	FileLoader,
 	Float32BufferAttribute,
 	Group,
@@ -15,14 +16,21 @@ import {
 	MeshStandardMaterial,
 	MirroredRepeatWrapping,
 	NearestFilter,
+	Quaternion,
 	RepeatWrapping,
+	SphereGeometry,
 	TextureLoader,
-	SRGBColorSpace
+	SRGBColorSpace,
+	Vector3
 } from '@gnsx/three';
 import { unzipSync } from '../libs/fflate.module.js';
+import { mergeGeometries } from '../utils/BufferGeometryUtils.js';
 
 const COLOR_SPACE_3MF = SRGBColorSpace;
 
+const NS_BEAM_LATTICE = 'http://schemas.microsoft.com/3dmanufacturing/beamlattice/2017/02';
+const NS_BEAM_LATTICE_BALLS = 'http://schemas.microsoft.com/3dmanufacturing/beamlattice/balls/2020/07';
+
 /**
  * A loader for the [3D Manufacturing Format (3MF)](https://3mf.io/specification/) format.
  *
@@ -38,6 +46,7 @@ const COLOR_SPACE_3MF = SRGBColorSpace;
  * - Texture 2D Groups
  * - Color Groups (Vertex Colors)
  * - Metallic Display Properties (PBR)
+ * - Beam Lattice
  *
  * ```js
  * const loader = new ThreeMFLoader();
@@ -604,10 +613,87 @@ class ThreeMFLoader extends Loader {
 			meshData[ 'triangleProperties' ] = triangleProperties;
 			meshData[ 'triangles' ] = new Uint32Array( triangles );
 
+			const beamLatticeNode = meshNode.getElementsByTagNameNS( NS_BEAM_LATTICE, 'beamlattice' )[ 0 ];
+
+			if ( beamLatticeNode !== undefined ) {
+
+				meshData[ 'beamlattice' ] = parseBeamLatticeNode( beamLatticeNode );
+
+			}
+
 			return meshData;
 
 		}
 
+		function parseBeamLatticeNode( beamLatticeNode ) {
+
+			const beamLatticeData = {
+				radius: parseFloat( beamLatticeNode.getAttribute( 'radius' ) ), // required
+				minLength: parseFloat( beamLatticeNode.getAttribute( 'minlength' ) ),
+				cap: beamLatticeNode.getAttribute( 'cap' ) || 'sphere',
+				ballMode: beamLatticeNode.getAttributeNS( NS_BEAM_LATTICE_BALLS, 'ballmode' ) || 'none',
+				ballRadius: parseFloat( beamLatticeNode.getAttributeNS( NS_BEAM_LATTICE_BALLS, 'ballradius' ) ),
+				beams: [],
+				balls: []
+			};
+
+			// clipping requires boolean operations which are not supported ('clipping' is a legacy name of 'clippingmode')
+
+			const clippingMode = beamLatticeNode.getAttribute( 'clippingmode' ) || beamLatticeNode.getAttribute( 'clipping' );
+
+			if ( clippingMode !== null && clippingMode !== 'none' ) {
+
+				console.warn( 'THREE.3MFLoader: Beam lattice clipping is not supported. The lattice is rendered unclipped.' );
+
+			}
+
+			const beamNodes = beamLatticeNode.getElementsByTagNameNS( NS_BEAM_LATTICE, 'beam' );
+
+			for ( let i = 0; i < beamNodes.length; i ++ ) {
+
+				const beamNode = beamNodes[ i ];
+
+				const beamData = {
+					v1: parseInt( beamNode.getAttribute( 'v1' ), 10 ), // required
+					v2: parseInt( beamNode.getAttribute( 'v2' ), 10 ) // required
+				};
+
+				// optional
+
+				const r1 = beamNode.getAttribute( 'r1' );
+				const r2 = beamNode.getAttribute( 'r2' );
+
+				if ( r1 !== null ) beamData[ 'r1' ] = parseFloat( r1 );
+				if ( r2 !== null ) beamData[ 'r2' ] = parseFloat( r2 );
+
+				beamLatticeData.beams.push( beamData );
+
+			}
+
+			const ballNodes = beamLatticeNode.getElementsByTagNameNS( NS_BEAM_LATTICE_BALLS, 'ball' );
+
+			for ( let i = 0; i < ballNodes.length; i ++ ) {
+
+				const ballNode = ballNodes[ i ];
+
+				const ballData = {
+					vindex: parseInt( ballNode.getAttribute( 'vindex' ), 10 ) // required
+				};
+
+				// optional
+
+				const r = ballNode.getAttribute( 'r' );
+
+				if ( r !== null ) ballData[ 'r' ] = parseFloat( r );
+
+				beamLatticeData.balls.push( ballData );
+
+			}
+
+			return beamLatticeData;
+
+		}
+
 		function parseComponentsNode( componentsNode ) {
 
 			const components = [];
@@ -1211,6 +1297,111 @@ class ThreeMFLoader extends Loader {
 
 		}
 
+		function buildLatticeMesh( meshData ) {
+
+			const beamLatticeData = meshData[ 'beamlattice' ];
+			const vertices = meshData[ 'vertices' ];
+
+			const geometries = [];
+
+			const p1 = new Vector3();
+			const p2 = new Vector3();
+			const direction = new Vector3();
+			const up = new Vector3( 0, 1, 0 );
+			const quaternion = new Quaternion();
+			const matrix = new Matrix4();
+
+			// beams
+
+			const beams = beamLatticeData.beams;
+			const openEnded = beamLatticeData.cap !== 'butt';
+
+			// spheres for caps and balls are collected per vertex so joints are only built once
+
+			const sphereRadii = new Map();
+
+			for ( let i = 0; i < beams.length; i ++ ) {
+
+				const beam = beams[ i ];
+
+				p1.fromArray( vertices, beam.v1 * 3 );
+				p2.fromArray( vertices, beam.v2 * 3 );
+
+				const length = p1.distanceTo( p2 );
+
+				if ( length < beamLatticeData.minLength ) continue; // consumers must ignore beams shorter than "minlength"
+
+				const r1 = ( beam.r1 !== undefined ) ? beam.r1 : beamLatticeData.radius;
+				const r2 = ( beam.r2 !== undefined ) ? beam.r2 : r1;
+
+				const geometry = new CylinderGeometry( r2, r1, length, 8, 1, openEnded );
+
+				direction.subVectors( p2, p1 ).divideScalar( length );
+				quaternion.setFromUnitVectors( up, direction );
+
+				matrix.makeRotationFromQuaternion( quaternion );
+				matrix.setPosition( p1.add( p2 ).multiplyScalar( 0.5 ) );
+
+				geometry.applyMatrix4( matrix );
+				geometries.push( geometry );
+
+				if ( openEnded ) {
+
+					// approximate "sphere" and "hemisphere" caps with a sphere per beam end
+
+					sphereRadii.set( beam.v1, Math.max( r1, sphereRadii.get( beam.v1 ) || 0 ) );
+					sphereRadii.set( beam.v2, Math.max( r2, sphereRadii.get( beam.v2 ) || 0 ) );
+
+				}
+
+				if ( beamLatticeData.ballMode === 'all' ) {
+
+					sphereRadii.set( beam.v1, Math.max( beamLatticeData.ballRadius, sphereRadii.get( beam.v1 ) || 0 ) );
+					sphereRadii.set( beam.v2, Math.max( beamLatticeData.ballRadius, sphereRadii.get( beam.v2 ) || 0 ) );
+
+				}
+
+			}
+
+			// balls
+
+			const balls = beamLatticeData.balls;
+
+			for ( let i = 0; i < balls.length; i ++ ) {
+
+				const ball = balls[ i ];
+				const r = ( ball.r !== undefined ) ? ball.r : beamLatticeData.ballRadius;
+
+				sphereRadii.set( ball.vindex, Math.max( r, sphereRadii.get( ball.vindex ) || 0 ) );
+
+			}
+
+			for ( const [ vindex, radius ] of sphereRadii ) {
+
+				const geometry = new SphereGeometry( radius, 8, 6 );
+
+				p1.fromArray( vertices, vindex * 3 );
+				geometry.translate( p1.x, p1.y, p1.z );
+
+				geometries.push( geometry );
+
+			}
+
+			//
+
+			const geometry = mergeGeometries( geometries );
+
+			const material = new MeshPhongMaterial( {
+				name: Loader.DEFAULT_MATERIAL_NAME,
+				color: 0xffffff
+			} );
+
+			const mesh = new Mesh( geometry, material );
+
+			return mesh;
+
+		}
+
 		function buildMeshes( resourceMap, meshData, objects, modelData, textureData, objectData ) {
 
 			const keys = Object.keys( resourceMap );
@@ -1329,6 +1520,16 @@ class ThreeMFLoader extends Loader {
 			const resourceMap = analyzeObject( meshData, objectData );
 			const meshes = buildMeshes( resourceMap, meshData, objects, modelData, textureData, objectData );
 
+			if ( meshData[ 'beamlattice' ] !== undefined ) {
+
+				const latticeMesh = buildLatticeMesh( meshData );
+
+				if ( objectData.name ) latticeMesh.name = objectData.name;
+
+				meshes.push( latticeMesh );
+
+			}
+
 			for ( let i = 0, l = meshes.length; i < l; i ++ ) {
 
 				group.add( meshes[ i ] );