/** * @version 1.1.1 * * @desc Load files in LWO3 and LWO2 format on Three.js * * LWO3 format specification: * https://static.lightwave3d.com/sdk/2019/html/filefmts/lwo3.html * * LWO2 format specification: * https://static.lightwave3d.com/sdk/2019/html/filefmts/lwo2.html * **/ import { AddOperation, BackSide, BufferGeometry, ClampToEdgeWrapping, Color, DoubleSide, EquirectangularReflectionMapping, EquirectangularRefractionMapping, FileLoader, Float32BufferAttribute, FrontSide, LineBasicMaterial, LineSegments, Loader, Mesh, MeshPhongMaterial, MeshPhysicalMaterial, MeshStandardMaterial, MirroredRepeatWrapping, Points, PointsMaterial, RepeatWrapping, SRGBColorSpace, TextureLoader, Vector2 } from 'three'; import { IFFParser } from './lwo/IFFParser.js'; let _lwoTree; class LWOLoader extends Loader { constructor( manager, parameters = {} ) { super( manager ); this.resourcePath = ( parameters.resourcePath !== undefined ) ? parameters.resourcePath : ''; } load( url, onLoad, onProgress, onError ) { const scope = this; const path = ( scope.path === '' ) ? extractParentUrl( url, 'Objects' ) : scope.path; // give the mesh a default name based on the filename const modelName = url.split( path ).pop().split( '.' )[ 0 ]; const loader = new FileLoader( this.manager ); loader.setPath( scope.path ); loader.setResponseType( 'arraybuffer' ); loader.load( url, function ( buffer ) { // console.time( 'Total parsing: ' ); try { onLoad( scope.parse( buffer, path, modelName ) ); } catch ( e ) { if ( onError ) { onError( e ); } else { console.error( e ); } scope.manager.itemError( url ); } // console.timeEnd( 'Total parsing: ' ); }, onProgress, onError ); } parse( iffBuffer, path, modelName ) { _lwoTree = new IFFParser().parse( iffBuffer ); // console.log( 'lwoTree', lwoTree ); const textureLoader = new TextureLoader( this.manager ).setPath( this.resourcePath || path ).setCrossOrigin( this.crossOrigin ); return new LWOTreeParser( textureLoader ).parse( modelName ); } } // Parse the lwoTree object class LWOTreeParser { constructor( textureLoader ) { this.textureLoader = textureLoader; } parse( modelName ) { this.materials = new MaterialParser( this.textureLoader ).parse(); this.defaultLayerName = modelName; this.meshes = this.parseLayers(); return { materials: this.materials, meshes: this.meshes, }; } parseLayers() { // array of all meshes for building hierarchy const meshes = []; // final array containing meshes with scene graph hierarchy set up const finalMeshes = []; const geometryParser = new GeometryParser(); const scope = this; _lwoTree.layers.forEach( function ( layer ) { const geometry = geometryParser.parse( layer.geometry, layer ); const mesh = scope.parseMesh( geometry, layer ); meshes[ layer.number ] = mesh; if ( layer.parent === - 1 ) finalMeshes.push( mesh ); else meshes[ layer.parent ].add( mesh ); } ); this.applyPivots( finalMeshes ); return finalMeshes; } parseMesh( geometry, layer ) { let mesh; const materials = this.getMaterials( geometry.userData.matNames, layer.geometry.type ); if ( layer.geometry.type === 'points' ) mesh = new Points( geometry, materials ); else if ( layer.geometry.type === 'lines' ) mesh = new LineSegments( geometry, materials ); else mesh = new Mesh( geometry, materials ); if ( layer.name ) mesh.name = layer.name; else mesh.name = this.defaultLayerName + '_layer_' + layer.number; mesh.userData.pivot = layer.pivot; return mesh; } // TODO: may need to be reversed in z to convert LWO to three.js coordinates applyPivots( meshes ) { meshes.forEach( function ( mesh ) { mesh.traverse( function ( child ) { const pivot = child.userData.pivot; child.position.x += pivot[ 0 ]; child.position.y += pivot[ 1 ]; child.position.z += pivot[ 2 ]; if ( child.parent ) { const parentPivot = child.parent.userData.pivot; child.position.x -= parentPivot[ 0 ]; child.position.y -= parentPivot[ 1 ]; child.position.z -= parentPivot[ 2 ]; } } ); } ); } getMaterials( namesArray, type ) { const materials = []; const scope = this; namesArray.forEach( function ( name, i ) { materials[ i ] = scope.getMaterialByName( name ); } ); // convert materials to line or point mats if required if ( type === 'points' || type === 'lines' ) { materials.forEach( function ( mat, i ) { const spec = { color: mat.color, }; if ( type === 'points' ) { spec.size = 0.1; spec.map = mat.map; materials[ i ] = new PointsMaterial( spec ); } else if ( type === 'lines' ) { materials[ i ] = new LineBasicMaterial( spec ); } } ); } // if there is only one material, return that directly instead of array const filtered = materials.filter( Boolean ); if ( filtered.length === 1 ) return filtered[ 0 ]; return materials; } getMaterialByName( name ) { return this.materials.filter( function ( m ) { return m.name === name; } )[ 0 ]; } } class MaterialParser { constructor( textureLoader ) { this.textureLoader = textureLoader; } parse() { const materials = []; this.textures = {}; for ( const name in _lwoTree.materials ) { if ( _lwoTree.format === 'LWO3' ) { materials.push( this.parseMaterial( _lwoTree.materials[ name ], name, _lwoTree.textures ) ); } else if ( _lwoTree.format === 'LWO2' ) { materials.push( this.parseMaterialLwo2( _lwoTree.materials[ name ], name, _lwoTree.textures ) ); } } return materials; } parseMaterial( materialData, name, textures ) { let params = { name: name, side: this.getSide( materialData.attributes ), flatShading: this.getSmooth( materialData.attributes ), }; const connections = this.parseConnections( materialData.connections, materialData.nodes ); const maps = this.parseTextureNodes( connections.maps ); this.parseAttributeImageMaps( connections.attributes, textures, maps, materialData.maps ); const attributes = this.parseAttributes( connections.attributes, maps ); this.parseEnvMap( connections, maps, attributes ); params = Object.assign( maps, params ); params = Object.assign( params, attributes ); const materialType = this.getMaterialType( connections.attributes ); if ( materialType !== MeshPhongMaterial ) delete params.refractionRatio; // PBR materials do not support "refractionRatio" return new materialType( params ); } parseMaterialLwo2( materialData, name/*, textures*/ ) { let params = { name: name, side: this.getSide( materialData.attributes ), flatShading: this.getSmooth( materialData.attributes ), }; const attributes = this.parseAttributes( materialData.attributes, {} ); params = Object.assign( params, attributes ); return new MeshPhongMaterial( params ); } // Note: converting from left to right handed coords by switching x -> -x in vertices, and // then switching mat FrontSide -> BackSide // NB: this means that FrontSide and BackSide have been switched! getSide( attributes ) { if ( ! attributes.side ) return BackSide; switch ( attributes.side ) { case 0: case 1: return BackSide; case 2: return FrontSide; case 3: return DoubleSide; } } getSmooth( attributes ) { if ( ! attributes.smooth ) return true; return ! attributes.smooth; } parseConnections( connections, nodes ) { const materialConnections = { maps: {} }; const inputName = connections.inputName; const inputNodeName = connections.inputNodeName; const nodeName = connections.nodeName; const scope = this; inputName.forEach( function ( name, index ) { if ( name === 'Material' ) { const matNode = scope.getNodeByRefName( inputNodeName[ index ], nodes ); materialConnections.attributes = matNode.attributes; materialConnections.envMap = matNode.fileName; materialConnections.name = inputNodeName[ index ]; } } ); nodeName.forEach( function ( name, index ) { if ( name === materialConnections.name ) { materialConnections.maps[ inputName[ index ] ] = scope.getNodeByRefName( inputNodeName[ index ], nodes ); } } ); return materialConnections; } getNodeByRefName( refName, nodes ) { for ( const name in nodes ) { if ( nodes[ name ].refName === refName ) return nodes[ name ]; } } parseTextureNodes( textureNodes ) { const maps = {}; for ( const name in textureNodes ) { const node = textureNodes[ name ]; const path = node.fileName; if ( ! path ) return; const texture = this.loadTexture( path ); if ( node.widthWrappingMode !== undefined ) texture.wrapS = this.getWrappingType( node.widthWrappingMode ); if ( node.heightWrappingMode !== undefined ) texture.wrapT = this.getWrappingType( node.heightWrappingMode ); switch ( name ) { case 'Color': maps.map = texture; maps.map.colorSpace = SRGBColorSpace; break; case 'Roughness': maps.roughnessMap = texture; maps.roughness = 1; break; case 'Specular': maps.specularMap = texture; maps.specularMap.colorSpace = SRGBColorSpace; maps.specular = 0xffffff; break; case 'Luminous': maps.emissiveMap = texture; maps.emissiveMap.colorSpace = SRGBColorSpace; maps.emissive = 0x808080; break; case 'Luminous Color': maps.emissive = 0x808080; break; case 'Metallic': maps.metalnessMap = texture; maps.metalness = 1; break; case 'Transparency': case 'Alpha': maps.alphaMap = texture; maps.transparent = true; break; case 'Normal': maps.normalMap = texture; if ( node.amplitude !== undefined ) maps.normalScale = new Vector2( node.amplitude, node.amplitude ); break; case 'Bump': maps.bumpMap = texture; break; } } // LWO BSDF materials can have both spec and rough, but this is not valid in three if ( maps.roughnessMap && maps.specularMap ) delete maps.specularMap; return maps; } // maps can also be defined on individual material attributes, parse those here // This occurs on Standard (Phong) surfaces parseAttributeImageMaps( attributes, textures, maps ) { for ( const name in attributes ) { const attribute = attributes[ name ]; if ( attribute.maps ) { const mapData = attribute.maps[ 0 ]; const path = this.getTexturePathByIndex( mapData.imageIndex, textures ); if ( ! path ) return; const texture = this.loadTexture( path ); if ( mapData.wrap !== undefined ) texture.wrapS = this.getWrappingType( mapData.wrap.w ); if ( mapData.wrap !== undefined ) texture.wrapT = this.getWrappingType( mapData.wrap.h ); switch ( name ) { case 'Color': maps.map = texture; maps.map.colorSpace = SRGBColorSpace; break; case 'Diffuse': maps.aoMap = texture; break; case 'Roughness': maps.roughnessMap = texture; maps.roughness = 1; break; case 'Specular': maps.specularMap = texture; maps.specularMap.colorSpace = SRGBColorSpace; maps.specular = 0xffffff; break; case 'Luminosity': maps.emissiveMap = texture; maps.emissiveMap.colorSpace = SRGBColorSpace; maps.emissive = 0x808080; break; case 'Metallic': maps.metalnessMap = texture; maps.metalness = 1; break; case 'Transparency': case 'Alpha': maps.alphaMap = texture; maps.transparent = true; break; case 'Normal': maps.normalMap = texture; break; case 'Bump': maps.bumpMap = texture; break; } } } } parseAttributes( attributes, maps ) { const params = {}; // don't use color data if color map is present if ( attributes.Color && ! maps.map ) { params.color = new Color().fromArray( attributes.Color.value ); } else { params.color = new Color(); } if ( attributes.Transparency && attributes.Transparency.value !== 0 ) { params.opacity = 1 - attributes.Transparency.value; params.transparent = true; } if ( attributes[ 'Bump Height' ] ) params.bumpScale = attributes[ 'Bump Height' ].value * 0.1; this.parsePhysicalAttributes( params, attributes, maps ); this.parseStandardAttributes( params, attributes, maps ); this.parsePhongAttributes( params, attributes, maps ); return params; } parsePhysicalAttributes( params, attributes/*, maps*/ ) { if ( attributes.Clearcoat && attributes.Clearcoat.value > 0 ) { params.clearcoat = attributes.Clearcoat.value; if ( attributes[ 'Clearcoat Gloss' ] ) { params.clearcoatRoughness = 0.5 * ( 1 - attributes[ 'Clearcoat Gloss' ].value ); } } } parseStandardAttributes( params, attributes, maps ) { if ( attributes.Luminous ) { params.emissiveIntensity = attributes.Luminous.value; if ( attributes[ 'Luminous Color' ] && ! maps.emissive ) { params.emissive = new Color().fromArray( attributes[ 'Luminous Color' ].value ); } else { params.emissive = new Color( 0x808080 ); } } if ( attributes.Roughness && ! maps.roughnessMap ) params.roughness = attributes.Roughness.value; if ( attributes.Metallic && ! maps.metalnessMap ) params.metalness = attributes.Metallic.value; } parsePhongAttributes( params, attributes, maps ) { if ( attributes[ 'Refraction Index' ] ) params.refractionRatio = 0.98 / attributes[ 'Refraction Index' ].value; if ( attributes.Diffuse ) params.color.multiplyScalar( attributes.Diffuse.value ); if ( attributes.Reflection ) { params.reflectivity = attributes.Reflection.value; params.combine = AddOperation; } if ( attributes.Luminosity ) { params.emissiveIntensity = attributes.Luminosity.value; if ( ! maps.emissiveMap && ! maps.map ) { params.emissive = params.color; } else { params.emissive = new Color( 0x808080 ); } } // parse specular if there is no roughness - we will interpret the material as 'Phong' in this case if ( ! attributes.Roughness && attributes.Specular && ! maps.specularMap ) { if ( attributes[ 'Color Highlight' ] ) { params.specular = new Color().setScalar( attributes.Specular.value ).lerp( params.color.clone().multiplyScalar( attributes.Specular.value ), attributes[ 'Color Highlight' ].value ); } else { params.specular = new Color().setScalar( attributes.Specular.value ); } } if ( params.specular && attributes.Glossiness ) params.shininess = 7 + Math.pow( 2, attributes.Glossiness.value * 12 + 2 ); } parseEnvMap( connections, maps, attributes ) { if ( connections.envMap ) { const envMap = this.loadTexture( connections.envMap ); if ( attributes.transparent && attributes.opacity < 0.999 ) { envMap.mapping = EquirectangularRefractionMapping; // Reflectivity and refraction mapping don't work well together in Phong materials if ( attributes.reflectivity !== undefined ) { delete attributes.reflectivity; delete attributes.combine; } if ( attributes.metalness !== undefined ) { attributes.metalness = 1; // For most transparent materials metalness should be set to 1 if not otherwise defined. If set to 0 no refraction will be visible } attributes.opacity = 1; // transparency fades out refraction, forcing opacity to 1 ensures a closer visual match to the material in Lightwave. } else envMap.mapping = EquirectangularReflectionMapping; maps.envMap = envMap; } } // get texture defined at top level by its index getTexturePathByIndex( index ) { let fileName = ''; if ( ! _lwoTree.textures ) return fileName; _lwoTree.textures.forEach( function ( texture ) { if ( texture.index === index ) fileName = texture.fileName; } ); return fileName; } loadTexture( path ) { if ( ! path ) return null; const texture = this.textureLoader.load( path, undefined, undefined, function () { console.warn( 'LWOLoader: non-standard resource hierarchy. Use \`resourcePath\` parameter to specify root content directory.' ); } ); return texture; } // 0 = Reset, 1 = Repeat, 2 = Mirror, 3 = Edge getWrappingType( num ) { switch ( num ) { case 0: console.warn( 'LWOLoader: "Reset" texture wrapping type is not supported in three.js' ); return ClampToEdgeWrapping; case 1: return RepeatWrapping; case 2: return MirroredRepeatWrapping; case 3: return ClampToEdgeWrapping; } } getMaterialType( nodeData ) { if ( nodeData.Clearcoat && nodeData.Clearcoat.value > 0 ) return MeshPhysicalMaterial; if ( nodeData.Roughness ) return MeshStandardMaterial; return MeshPhongMaterial; } } class GeometryParser { parse( geoData, layer ) { const geometry = new BufferGeometry(); geometry.setAttribute( 'position', new Float32BufferAttribute( geoData.points, 3 ) ); const indices = this.splitIndices( geoData.vertexIndices, geoData.polygonDimensions ); geometry.setIndex( indices ); this.parseGroups( geometry, geoData ); geometry.computeVertexNormals(); this.parseUVs( geometry, layer, indices ); this.parseMorphTargets( geometry, layer, indices ); // TODO: z may need to be reversed to account for coordinate system change geometry.translate( - layer.pivot[ 0 ], - layer.pivot[ 1 ], - layer.pivot[ 2 ] ); // let userData = geometry.userData; // geometry = geometry.toNonIndexed() // geometry.userData = userData; return geometry; } // split quads into tris splitIndices( indices, polygonDimensions ) { const remappedIndices = []; let i = 0; polygonDimensions.forEach( function ( dim ) { if ( dim < 4 ) { for ( let k = 0; k < dim; k ++ ) remappedIndices.push( indices[ i + k ] ); } else if ( dim === 4 ) { remappedIndices.push( indices[ i ], indices[ i + 1 ], indices[ i + 2 ], indices[ i ], indices[ i + 2 ], indices[ i + 3 ] ); } else if ( dim > 4 ) { for ( let k = 1; k < dim - 1; k ++ ) { remappedIndices.push( indices[ i ], indices[ i + k ], indices[ i + k + 1 ] ); } console.warn( 'LWOLoader: polygons with greater than 4 sides are not supported' ); } i += dim; } ); return remappedIndices; } // NOTE: currently ignoring poly indices and assuming that they are intelligently ordered parseGroups( geometry, geoData ) { const tags = _lwoTree.tags; const matNames = []; let elemSize = 3; if ( geoData.type === 'lines' ) elemSize = 2; if ( geoData.type === 'points' ) elemSize = 1; const remappedIndices = this.splitMaterialIndices( geoData.polygonDimensions, geoData.materialIndices ); let indexNum = 0; // create new indices in numerical order const indexPairs = {}; // original indices mapped to numerical indices let prevMaterialIndex; let materialIndex; let prevStart = 0; let currentCount = 0; for ( let i = 0; i < remappedIndices.length; i += 2 ) { materialIndex = remappedIndices[ i + 1 ]; if ( i === 0 ) matNames[ indexNum ] = tags[ materialIndex ]; if ( prevMaterialIndex === undefined ) prevMaterialIndex = materialIndex; if ( materialIndex !== prevMaterialIndex ) { let currentIndex; if ( indexPairs[ tags[ prevMaterialIndex ] ] ) { currentIndex = indexPairs[ tags[ prevMaterialIndex ] ]; } else { currentIndex = indexNum; indexPairs[ tags[ prevMaterialIndex ] ] = indexNum; matNames[ indexNum ] = tags[ prevMaterialIndex ]; indexNum ++; } geometry.addGroup( prevStart, currentCount, currentIndex ); prevStart += currentCount; prevMaterialIndex = materialIndex; currentCount = 0; } currentCount += elemSize; } // the loop above doesn't add the last group, do that here. if ( geometry.groups.length > 0 ) { let currentIndex; if ( indexPairs[ tags[ materialIndex ] ] ) { currentIndex = indexPairs[ tags[ materialIndex ] ]; } else { currentIndex = indexNum; indexPairs[ tags[ materialIndex ] ] = indexNum; matNames[ indexNum ] = tags[ materialIndex ]; } geometry.addGroup( prevStart, currentCount, currentIndex ); } // Mat names from TAGS chunk, used to build up an array of materials for this geometry geometry.userData.matNames = matNames; } splitMaterialIndices( polygonDimensions, indices ) { const remappedIndices = []; polygonDimensions.forEach( function ( dim, i ) { if ( dim <= 3 ) { remappedIndices.push( indices[ i * 2 ], indices[ i * 2 + 1 ] ); } else if ( dim === 4 ) { remappedIndices.push( indices[ i * 2 ], indices[ i * 2 + 1 ], indices[ i * 2 ], indices[ i * 2 + 1 ] ); } else { // ignore > 4 for now for ( let k = 0; k < dim - 2; k ++ ) { remappedIndices.push( indices[ i * 2 ], indices[ i * 2 + 1 ] ); } } } ); return remappedIndices; } // UV maps: // 1: are defined via index into an array of points, not into a geometry // - the geometry is also defined by an index into this array, but the indexes may not match // 2: there can be any number of UV maps for a single geometry. Here these are combined, // with preference given to the first map encountered // 3: UV maps can be partial - that is, defined for only a part of the geometry // 4: UV maps can be VMAP or VMAD (discontinuous, to allow for seams). In practice, most // UV maps are defined as partially VMAP and partially VMAD // VMADs are currently not supported parseUVs( geometry, layer ) { // start by creating a UV map set to zero for the whole geometry const remappedUVs = Array.from( Array( geometry.attributes.position.count * 2 ), function () { return 0; } ); for ( const name in layer.uvs ) { const uvs = layer.uvs[ name ].uvs; const uvIndices = layer.uvs[ name ].uvIndices; uvIndices.forEach( function ( i, j ) { remappedUVs[ i * 2 ] = uvs[ j * 2 ]; remappedUVs[ i * 2 + 1 ] = uvs[ j * 2 + 1 ]; } ); } geometry.setAttribute( 'uv', new Float32BufferAttribute( remappedUVs, 2 ) ); } parseMorphTargets( geometry, layer ) { let num = 0; for ( const name in layer.morphTargets ) { const remappedPoints = geometry.attributes.position.array.slice(); if ( ! geometry.morphAttributes.position ) geometry.morphAttributes.position = []; const morphPoints = layer.morphTargets[ name ].points; const morphIndices = layer.morphTargets[ name ].indices; const type = layer.morphTargets[ name ].type; morphIndices.forEach( function ( i, j ) { if ( type === 'relative' ) { remappedPoints[ i * 3 ] += morphPoints[ j * 3 ]; remappedPoints[ i * 3 + 1 ] += morphPoints[ j * 3 + 1 ]; remappedPoints[ i * 3 + 2 ] += morphPoints[ j * 3 + 2 ]; } else { remappedPoints[ i * 3 ] = morphPoints[ j * 3 ]; remappedPoints[ i * 3 + 1 ] = morphPoints[ j * 3 + 1 ]; remappedPoints[ i * 3 + 2 ] = morphPoints[ j * 3 + 2 ]; } } ); geometry.morphAttributes.position[ num ] = new Float32BufferAttribute( remappedPoints, 3 ); geometry.morphAttributes.position[ num ].name = name; num ++; } geometry.morphTargetsRelative = false; } } // ************** UTILITY FUNCTIONS ************** function extractParentUrl( url, dir ) { const index = url.indexOf( dir ); if ( index === - 1 ) return './'; return url.slice( 0, index ); } export { LWOLoader };