three.js/examples/jsm/loaders/IFCLoader.js

import {
	IFCRELAGGREGATES,
	IFCRELCONTAINEDINSPATIALSTRUCTURE,
	IFCRELDEFINESBYPROPERTIES,
	IFCRELDEFINESBYTYPE,
	IFCPROJECT,
	IfcAPI,
} from './ifc/web-ifc-api.js';
import {
	BufferAttribute,
	BufferGeometry,
	Mesh,
	Matrix4,
	Color,
	MeshLambertMaterial,
	DoubleSide,
	Group,
	Loader,
	FileLoader,
} from '../../../build/three.module.js';
import * as BufferGeometryUtils from '../utils/BufferGeometryUtils.js';

const IdAttrName = 'expressID';
const merge = ( geoms, createGroups = false ) => {

	return BufferGeometryUtils.mergeBufferGeometries( geoms, createGroups );

};

const newFloatAttr = ( data, size ) => {

	return new BufferAttribute( new Float32Array( data ), size );

};

const newIntAttr = ( data, size ) => {

	return new BufferAttribute( new Uint32Array( data ), size );

};

const DEFAULT = 'default';
const PropsNames = {
	aggregates: {
		name: IFCRELAGGREGATES,
		relating: 'RelatingObject',
		related: 'RelatedObjects',
		key: 'children',
	},
	spatial: {
		name: IFCRELCONTAINEDINSPATIALSTRUCTURE,
		relating: 'RelatingStructure',
		related: 'RelatedElements',
		key: 'children',
	},
	psets: {
		name: IFCRELDEFINESBYPROPERTIES,
		relating: 'RelatingPropertyDefinition',
		related: 'RelatedObjects',
		key: 'hasPsets',
	},
	type: {
		name: IFCRELDEFINESBYTYPE,
		relating: 'RelatingType',
		related: 'RelatedObjects',
		key: 'hasType',
	},
};

class IFCParser {

	constructor( state ) {

		this.currentID = - 1;
		this.state = state;

	}

	async parse( buffer ) {

		if ( this.state.api.wasmModule === undefined ) await this.state.api.Init();
		this.currentID = this.newIfcModel( buffer );
		return this.loadAllGeometry();

	}

	initializeMeshBVH( computeBoundsTree, disposeBoundsTree, acceleratedRaycast ) {

		this.computeBoundsTree = computeBoundsTree;
		this.disposeBoundsTree = disposeBoundsTree;
		this.acceleratedRaycast = acceleratedRaycast;
		this.setupThreeMeshBVH();

	}

	setupThreeMeshBVH() {

		if (
			! this.computeBoundsTree ||
			! this.disposeBoundsTree ||
			! this.acceleratedRaycast
		)
			return;
		BufferGeometry.prototype.computeBoundsTree = this.computeBoundsTree;
		BufferGeometry.prototype.disposeBoundsTree = this.disposeBoundsTree;
		Mesh.prototype.raycast = this.acceleratedRaycast;

	}

	applyThreeMeshBVH( geometry ) {

		if ( this.computeBoundsTree ) geometry.computeBoundsTree();

	}

	newIfcModel( buffer ) {

		const data = new Uint8Array( buffer );
		const modelID = this.state.api.OpenModel( data );
		this.state.models[ modelID ] = {
			modelID,
			mesh: {},
			items: {},
			types: {},
		};
		return modelID;

	}

	loadAllGeometry() {

		this.saveAllPlacedGeometriesByMaterial();
		return this.generateAllGeometriesByMaterial();

	}

	generateAllGeometriesByMaterial() {

		const { geometry, materials } = this.getGeometryAndMaterials();
		this.applyThreeMeshBVH( geometry );
		const mesh = new Mesh( geometry, materials );
		mesh.modelID = this.currentID;
		this.state.models[ this.currentID ].mesh = mesh;
		return mesh;

	}

	getGeometryAndMaterials() {

		const items = this.state.models[ this.currentID ].items;
		const mergedByMaterial = [];
		const materials = [];
		for ( const materialID in items ) {

			materials.push( items[ materialID ].material );
			const geometries = Object.values( items[ materialID ].geometries );
			mergedByMaterial.push( merge( geometries ) );

		}

		const geometry = merge( mergedByMaterial, true );
		return {
			geometry,
			materials,
		};

	}

	saveAllPlacedGeometriesByMaterial() {

		const flatMeshes = this.state.api.LoadAllGeometry( this.currentID );
		for ( let i = 0; i < flatMeshes.size(); i ++ ) {

			const flatMesh = flatMeshes.get( i );
			const placedGeom = flatMesh.geometries;
			for ( let j = 0; j < placedGeom.size(); j ++ ) {

				this.savePlacedGeometry( placedGeom.get( j ), flatMesh.expressID );

			}

		}

	}

	savePlacedGeometry( placedGeometry, id ) {

		const geometry = this.getBufferGeometry( placedGeometry );
		geometry.computeVertexNormals();
		const matrix = this.getMeshMatrix( placedGeometry.flatTransformation );
		geometry.applyMatrix4( matrix );
		this.saveGeometryByMaterial( geometry, placedGeometry, id );

	}

	getBufferGeometry( placed ) {

		const geometry = this.state.api.GetGeometry(
			this.currentID,
			placed.geometryExpressID
		);
		const vertexData = this.getVertices( geometry );
		const indices = this.getIndices( geometry );
		const { vertices, normals } = this.extractVertexData( vertexData );
		return this.ifcGeomToBufferGeom( vertices, normals, indices );

	}

	getVertices( geometry ) {

		const vData = geometry.GetVertexData();
		const vDataSize = geometry.GetVertexDataSize();
		return this.state.api.GetVertexArray( vData, vDataSize );

	}

	getIndices( geometry ) {

		const iData = geometry.GetIndexData();
		const iDataSize = geometry.GetIndexDataSize();
		return this.state.api.GetIndexArray( iData, iDataSize );

	}

	getMeshMatrix( matrix ) {

		const mat = new Matrix4();
		mat.fromArray( matrix );
		return mat;

	}

	ifcGeomToBufferGeom( vertices, normals, indexData ) {

		const geometry = new BufferGeometry();
		geometry.setAttribute( 'position', newFloatAttr( vertices, 3 ) );
		geometry.setAttribute( 'normal', newFloatAttr( normals, 3 ) );
		geometry.setIndex( new BufferAttribute( indexData, 1 ) );
		return geometry;

	}

	extractVertexData( vertexData ) {

		const vertices = [];
		const normals = [];
		let isNormalData = false;
		for ( let i = 0; i < vertexData.length; i ++ ) {

			isNormalData ? normals.push( vertexData[ i ] ) : vertices.push( vertexData[ i ] );
			if ( ( i + 1 ) % 3 == 0 ) isNormalData = ! isNormalData;

		}

		return {
			vertices,
			normals,
		};

	}

	saveGeometryByMaterial( geom, placedGeom, id ) {

		const color = placedGeom.color;
		const colorID = `${color.x}${color.y}${color.z}${color.w}`;
		this.storeGeometryAttribute( id, geom );
		this.createMaterial( colorID, color );
		const item = this.state.models[ this.currentID ].items[ colorID ];
		const currentGeom = item.geometries[ id ];
		if ( ! currentGeom ) return ( item.geometries[ id ] = geom );
		const merged = merge( [ currentGeom, geom ] );
		item.geometries[ id ] = merged;

	}

	storeGeometryAttribute( id, geometry ) {

		const size = geometry.attributes.position.count;
		const idAttribute = new Array( size ).fill( id );
		geometry.setAttribute( IdAttrName, newIntAttr( idAttribute, 1 ) );

	}

	createMaterial( colorID, color ) {

		const items = this.state.models[ this.currentID ].items;
		if ( items[ colorID ] ) return;
		const col = new Color( color.x, color.y, color.z );
		const newMaterial = new MeshLambertMaterial( {
			color: col,
			side: DoubleSide,
		} );
		newMaterial.transparent = color.w !== 1;
		if ( newMaterial.transparent ) newMaterial.opacity = color.w;
		items[ colorID ] = {
			material: newMaterial,
			geometries: {},
		};

	}

}

class SubsetManager {

	constructor( state ) {

		this.state = state;
		this.selected = {};

	}

	getSubset( modelID, material ) {

		const currentMat = this.matIDNoConfig( modelID, material );
		if ( ! this.selected[ currentMat ] ) return null;
		return this.selected[ currentMat ].mesh;

	}

	removeSubset( modelID, scene, material ) {

		const currentMat = this.matIDNoConfig( modelID, material );
		if ( ! this.selected[ currentMat ] ) return;
		if ( scene ) scene.remove( this.selected[ currentMat ].mesh );
		delete this.selected[ currentMat ];

	}

	createSubset( config ) {

		if ( ! this.isConfigValid( config ) ) return;
		if ( this.isPreviousSelection( config ) ) return;
		if ( this.isEasySelection( config ) )
			return this.addToPreviousSelection( config );
		this.updatePreviousSelection( config.scene, config );
		return this.createSelectionInScene( config );

	}

	createSelectionInScene( config ) {

		const filtered = this.filter( config );
		const { geomsByMaterial, materials } = this.getGeomAndMat( filtered );
		const hasDefaultMaterial = this.matID( config ) == DEFAULT;
		const geometry = merge( geomsByMaterial, hasDefaultMaterial );
		const mats = hasDefaultMaterial ? materials : config.material;
		const mesh = new Mesh( geometry, mats );
		this.selected[ this.matID( config ) ].mesh = mesh;
		mesh.modelID = config.modelID;
		config.scene.add( mesh );
		return mesh;

	}

	isConfigValid( config ) {

		return (
			this.isValid( config.scene ) &&
			this.isValid( config.modelID ) &&
			this.isValid( config.ids ) &&
			this.isValid( config.removePrevious )
		);

	}

	isValid( item ) {

		return item != undefined && item != null;

	}

	getGeomAndMat( filtered ) {

		const geomsByMaterial = [];
		const materials = [];
		for ( const matID in filtered ) {

			const geoms = Object.values( filtered[ matID ].geometries );
			if ( ! geoms.length ) continue;
			materials.push( filtered[ matID ].material );
			if ( geoms.length > 1 ) geomsByMaterial.push( merge( geoms ) );
			else geomsByMaterial.push( ...geoms );

		}

		return {
			geomsByMaterial,
			materials,
		};

	}

	updatePreviousSelection( scene, config ) {

		const previous = this.selected[ this.matID( config ) ];
		if ( ! previous ) return this.newSelectionGroup( config );
		scene.remove( previous.mesh );
		config.removePrevious
			? ( previous.ids = new Set( config.ids ) )
			: config.ids.forEach( ( id ) => previous.ids.add( id ) );

	}

	newSelectionGroup( config ) {

		this.selected[ this.matID( config ) ] = {
			ids: new Set( config.ids ),
			mesh: {},
		};

	}

	isPreviousSelection( config ) {

		if ( ! this.selected[ this.matID( config ) ] ) return false;
		if ( this.containsIds( config ) ) return true;
		const previousIds = this.selected[ this.matID( config ) ].ids;
		return JSON.stringify( config.ids ) === JSON.stringify( previousIds );

	}

	containsIds( config ) {

		const newIds = config.ids;
		const previous = Array.from( this.selected[ this.matID( config ) ].ids );
		return newIds.every(
			(
				( i ) => ( v ) =>
					( i = previous.indexOf( v, i ) + 1 )
			)( 0 )
		);

	}

	addToPreviousSelection( config ) {

		const previous = this.selected[ this.matID( config ) ];
		const filtered = this.filter( config );
		const geometries = Object.values( filtered )
			.map( ( i ) => Object.values( i.geometries ) )
			.flat();
		const previousGeom = previous.mesh.geometry;
		previous.mesh.geometry = merge( [ previousGeom, ...geometries ] );
		config.ids.forEach( ( id ) => previous.ids.add( id ) );

	}

	filter( config ) {

		const items = this.state.models[ config.modelID ].items;
		const filtered = {};
		for ( const matID in items ) {

			filtered[ matID ] = {
				material: items[ matID ].material,
				geometries: this.filterGeometries(
					new Set( config.ids ),
					items[ matID ].geometries
				),
			};

		}

		return filtered;

	}

	filterGeometries( selectedIDs, geometries ) {

		const ids = Array.from( selectedIDs );
		return Object.keys( geometries )
			.filter( ( key ) => ids.includes( parseInt( key, 10 ) ) )
			.reduce( ( obj, key ) => {

				return {
					...obj,
					[ key ]: geometries[ key ],
				};

			}, {} );

	}

	isEasySelection( config ) {

		const matID = this.matID( config );
		const def = this.matIDNoConfig( config.modelID );
		if ( ! config.removePrevious && matID != def && this.selected[ matID ] )
			return true;

	}

	matID( config ) {

		if ( ! config.material ) return DEFAULT;
		const name = config.material.uuid || DEFAULT;
		return name.concat( ' - ' ).concat( config.modelID.toString() );

	}

	matIDNoConfig( modelID, material ) {

		let name = DEFAULT;
		if ( material ) name = material.uuid;
		return name.concat( ' - ' ).concat( modelID.toString() );

	}

}

const IfcElements = {
	103090709: 'IFCPROJECT',
	4097777520: 'IFCSITE',
	4031249490: 'IFCBUILDING',
	3124254112: 'IFCBUILDINGSTOREY',
	3856911033: 'IFCSPACE',
	25142252: 'IFCCONTROLLER',
	32344328: 'IFCBOILER',
	76236018: 'IFCLAMP',
	90941305: 'IFCPUMP',
	177149247: 'IFCAIRTERMINALBOX',
	182646315: 'IFCFLOWINSTRUMENT',
	263784265: 'IFCFURNISHINGELEMENT',
	264262732: 'IFCELECTRICGENERATOR',
	277319702: 'IFCAUDIOVISUALAPPLIANCE',
	310824031: 'IFCPIPEFITTING',
	331165859: 'IFCSTAIR',
	342316401: 'IFCDUCTFITTING',
	377706215: 'IFCMECHANICALFASTENER',
	395920057: 'IFCDOOR',
	402227799: 'IFCELECTRICMOTOR',
	413509423: 'IFCSYSTEMFURNITUREELEMENT',
	484807127: 'IFCEVAPORATOR',
	486154966: 'IFCWINDOWSTANDARDCASE',
	629592764: 'IFCLIGHTFIXTURE',
	630975310: 'IFCUNITARYCONTROLELEMENT',
	635142910: 'IFCCABLECARRIERFITTING',
	639361253: 'IFCCOIL',
	647756555: 'IFCFASTENER',
	707683696: 'IFCFLOWSTORAGEDEVICE',
	738039164: 'IFCPROTECTIVEDEVICE',
	753842376: 'IFCBEAM',
	812556717: 'IFCTANK',
	819412036: 'IFCFILTER',
	843113511: 'IFCCOLUMN',
	862014818: 'IFCELECTRICDISTRIBUTIONBOARD',
	900683007: 'IFCFOOTING',
	905975707: 'IFCCOLUMNSTANDARDCASE',
	926996030: 'IFCVOIDINGFEATURE',
	979691226: 'IFCREINFORCINGBAR',
	987401354: 'IFCFLOWSEGMENT',
	1003880860: 'IFCELECTRICTIMECONTROL',
	1051757585: 'IFCCABLEFITTING',
	1052013943: 'IFCDISTRIBUTIONCHAMBERELEMENT',
	1062813311: 'IFCDISTRIBUTIONCONTROLELEMENT',
	1073191201: 'IFCMEMBER',
	1095909175: 'IFCBUILDINGELEMENTPROXY',
	1156407060: 'IFCPLATESTANDARDCASE',
	1162798199: 'IFCSWITCHINGDEVICE',
	1329646415: 'IFCSHADINGDEVICE',
	1335981549: 'IFCDISCRETEACCESSORY',
	1360408905: 'IFCDUCTSILENCER',
	1404847402: 'IFCSTACKTERMINAL',
	1426591983: 'IFCFIRESUPPRESSIONTERMINAL',
	1437502449: 'IFCMEDICALDEVICE',
	1509553395: 'IFCFURNITURE',
	1529196076: 'IFCSLAB',
	1620046519: 'IFCTRANSPORTELEMENT',
	1634111441: 'IFCAIRTERMINAL',
	1658829314: 'IFCENERGYCONVERSIONDEVICE',
	1677625105: 'IFCCIVILELEMENT',
	1687234759: 'IFCPILE',
	1904799276: 'IFCELECTRICAPPLIANCE',
	1911478936: 'IFCMEMBERSTANDARDCASE',
	1945004755: 'IFCDISTRIBUTIONELEMENT',
	1973544240: 'IFCCOVERING',
	1999602285: 'IFCSPACEHEATER',
	2016517767: 'IFCROOF',
	2056796094: 'IFCAIRTOAIRHEATRECOVERY',
	2058353004: 'IFCFLOWCONTROLLER',
	2068733104: 'IFCHUMIDIFIER',
	2176052936: 'IFCJUNCTIONBOX',
	2188021234: 'IFCFLOWMETER',
	2223149337: 'IFCFLOWTERMINAL',
	2262370178: 'IFCRAILING',
	2272882330: 'IFCCONDENSER',
	2295281155: 'IFCPROTECTIVEDEVICETRIPPINGUNIT',
	2320036040: 'IFCREINFORCINGMESH',
	2347447852: 'IFCTENDONANCHOR',
	2391383451: 'IFCVIBRATIONISOLATOR',
	2391406946: 'IFCWALL',
	2474470126: 'IFCMOTORCONNECTION',
	2769231204: 'IFCVIRTUALELEMENT',
	2814081492: 'IFCENGINE',
	2906023776: 'IFCBEAMSTANDARDCASE',
	2938176219: 'IFCBURNER',
	2979338954: 'IFCBUILDINGELEMENTPART',
	3024970846: 'IFCRAMP',
	3026737570: 'IFCTUBEBUNDLE',
	3027962421: 'IFCSLABSTANDARDCASE',
	3040386961: 'IFCDISTRIBUTIONFLOWELEMENT',
	3053780830: 'IFCSANITARYTERMINAL',
	3079942009: 'IFCOPENINGSTANDARDCASE',
	3087945054: 'IFCALARM',
	3101698114: 'IFCSURFACEFEATURE',
	3127900445: 'IFCSLABELEMENTEDCASE',
	3132237377: 'IFCFLOWMOVINGDEVICE',
	3171933400: 'IFCPLATE',
	3221913625: 'IFCCOMMUNICATIONSAPPLIANCE',
	3242481149: 'IFCDOORSTANDARDCASE',
	3283111854: 'IFCRAMPFLIGHT',
	3296154744: 'IFCCHIMNEY',
	3304561284: 'IFCWINDOW',
	3310460725: 'IFCELECTRICFLOWSTORAGEDEVICE',
	3319311131: 'IFCHEATEXCHANGER',
	3415622556: 'IFCFAN',
	3420628829: 'IFCSOLARDEVICE',
	3493046030: 'IFCGEOGRAPHICELEMENT',
	3495092785: 'IFCCURTAINWALL',
	3508470533: 'IFCFLOWTREATMENTDEVICE',
	3512223829: 'IFCWALLSTANDARDCASE',
	3518393246: 'IFCDUCTSEGMENT',
	3571504051: 'IFCCOMPRESSOR',
	3588315303: 'IFCOPENINGELEMENT',
	3612865200: 'IFCPIPESEGMENT',
	3640358203: 'IFCCOOLINGTOWER',
	3651124850: 'IFCPROJECTIONELEMENT',
	3694346114: 'IFCOUTLET',
	3747195512: 'IFCEVAPORATIVECOOLER',
	3758799889: 'IFCCABLECARRIERSEGMENT',
	3824725483: 'IFCTENDON',
	3825984169: 'IFCTRANSFORMER',
	3902619387: 'IFCCHILLER',
	4074379575: 'IFCDAMPER',
	4086658281: 'IFCSENSOR',
	4123344466: 'IFCELEMENTASSEMBLY',
	4136498852: 'IFCCOOLEDBEAM',
	4156078855: 'IFCWALLELEMENTEDCASE',
	4175244083: 'IFCINTERCEPTOR',
	4207607924: 'IFCVALVE',
	4217484030: 'IFCCABLESEGMENT',
	4237592921: 'IFCWASTETERMINAL',
	4252922144: 'IFCSTAIRFLIGHT',
	4278956645: 'IFCFLOWFITTING',
	4288193352: 'IFCACTUATOR',
	4292641817: 'IFCUNITARYEQUIPMENT',
};

class PropertyManager {

	constructor( state ) {

		this.state = state;

	}

	getExpressId( geometry, faceIndex ) {

		if ( ! geometry.index ) return;
		const geoIndex = geometry.index.array;
		return geometry.attributes[ IdAttrName ].getX( geoIndex[ 3 * faceIndex ] );

	}

	getItemProperties( modelID, id, recursive = false ) {

		return this.state.api.GetLine( modelID, id, recursive );

	}

	getAllItemsOfType( modelID, type, verbose ) {

		const items = [];
		const lines = this.state.api.GetLineIDsWithType( modelID, type );
		for ( let i = 0; i < lines.size(); i ++ ) items.push( lines.get( i ) );
		if ( verbose ) return items.map( ( id ) => this.state.api.GetLine( modelID, id ) );
		return items;

	}

	getPropertySets( modelID, elementID, recursive = false ) {

		const propSetIds = this.getAllRelatedItemsOfType(
			modelID,
			elementID,
			PropsNames.psets
		);
		return propSetIds.map( ( id ) =>
			this.state.api.GetLine( modelID, id, recursive )
		);

	}

	getTypeProperties( modelID, elementID, recursive = false ) {

		const typeId = this.getAllRelatedItemsOfType(
			modelID,
			elementID,
			PropsNames.type
		);
		return typeId.map( ( id ) => this.state.api.GetLine( modelID, id, recursive ) );

	}

	getSpatialStructure( modelID ) {

		const chunks = this.getSpatialTreeChunks( modelID );
		const projectID = this.state.api
			.GetLineIDsWithType( modelID, IFCPROJECT )
			.get( 0 );
		const project = this.newIfcProject( projectID );
		this.getSpatialNode( modelID, project, chunks );
		return project;

	}

	newIfcProject( id ) {

		return {
			expressID: id,
			type: 'IFCPROJECT',
			children: [],
		};

	}

	getSpatialTreeChunks( modelID ) {

		const treeChunks = {};
		this.getChunks( modelID, treeChunks, PropsNames.aggregates );
		this.getChunks( modelID, treeChunks, PropsNames.spatial );
		return treeChunks;

	}

	getChunks( modelID, chunks, propNames ) {

		const relation = this.state.api.GetLineIDsWithType( modelID, propNames.name );
		for ( let i = 0; i < relation.size(); i ++ ) {

			const rel = this.state.api.GetLine( modelID, relation.get( i ), false );
			const relating = rel[ propNames.relating ].value;
			const related = rel[ propNames.related ].map( ( r ) => r.value );
			if ( chunks[ relating ] == undefined ) {

				chunks[ relating ] = related;

			} else {

				chunks[ relating ] = chunks[ relating ].concat( related );

			}

		}

	}

	getSpatialNode( modelID, node, treeChunks ) {

		this.getChildren( modelID, node, treeChunks, PropsNames.aggregates );
		this.getChildren( modelID, node, treeChunks, PropsNames.spatial );

	}

	getChildren( modelID, node, treeChunks, propNames ) {

		const children = treeChunks[ node.expressID ];
		if ( children == undefined || children == null ) return;
		const prop = propNames.key;
		node[ prop ] = children.map( ( child ) => {

			const node = this.newNode( modelID, child );
			this.getSpatialNode( modelID, node, treeChunks );
			return node;

		} );

	}

	newNode( modelID, id ) {

		const typeID = this.state.models[ modelID ].types[ id ].toString();
		const typeName = IfcElements[ typeID ];
		return {
			expressID: id,
			type: typeName,
			children: [],
		};

	}

	getAllRelatedItemsOfType( modelID, id, propNames ) {

		const lines = this.state.api.GetLineIDsWithType( modelID, propNames.name );
		const IDs = [];
		for ( let i = 0; i < lines.size(); i ++ ) {

			const rel = this.state.api.GetLine( modelID, lines.get( i ) );
			const isRelated = this.isRelated( id, rel, propNames );
			if ( isRelated ) this.getRelated( rel, propNames, IDs );

		}

		return IDs;

	}

	getRelated( rel, propNames, IDs ) {

		const element = rel[ propNames.relating ];
		if ( ! Array.isArray( element ) ) IDs.push( element.value );
		else element.forEach( ( ele ) => IDs.push( ele.value ) );

	}

	isRelated( id, rel, propNames ) {

		const relatedItems = rel[ propNames.related ];
		if ( Array.isArray( relatedItems ) ) {

			const values = relatedItems.map( ( item ) => item.value );
			return values.includes( id );

		}

		return relatedItems.value === id;

	}

}

class TypeManager {

	constructor( state ) {

		this.state = state;

	}

	getAllTypes() {

		for ( const modelID in this.state.models ) {

			const types = this.state.models[ modelID ].types;
			if ( Object.keys( types ).length == 0 )
				this.getAllTypesOfModel( parseInt( modelID ) );

		}

	}

	getAllTypesOfModel( modelID ) {

		this.state.models[ modelID ].types;
		const elements = Object.keys( IfcElements ).map( ( e ) => parseInt( e ) );
		const types = this.state.models[ modelID ].types;
		elements.forEach( ( type ) => {

			const lines = this.state.api.GetLineIDsWithType( modelID, type );
			for ( let i = 0; i < lines.size(); i ++ ) types[ lines.get( i ) ] = type;

		} );

	}

}

let modelIdCounter = 0;

class IFCModel extends Group {

	constructor( mesh, ifc ) {

		super();
		this.mesh = mesh;
		this.ifc = ifc;
		this.modelID = modelIdCounter ++;

	}

	setWasmPath( path ) {

		this.ifc.setWasmPath( path );

	}

	close( scene ) {

		this.ifc.close( this.modelID, scene );

	}

	getExpressId( geometry, faceIndex ) {

		return this.ifc.getExpressId( geometry, faceIndex );

	}

	getAllItemsOfType( type, verbose ) {

		return this.ifc.getAllItemsOfType( this.modelID, type, verbose );

	}

	getItemProperties( id, recursive = false ) {

		return this.ifc.getItemProperties( this.modelID, id, recursive );

	}

	getPropertySets( id, recursive = false ) {

		return this.ifc.getPropertySets( this.modelID, id, recursive );

	}

	getTypeProperties( id, recursive = false ) {

		return this.ifc.getTypeProperties( this.modelID, id, recursive );

	}

	getIfcType( id ) {

		return this.ifc.getIfcType( this.modelID, id );

	}

	getSpatialStructure() {

		return this.ifc.getSpatialStructure( this.modelID );

	}

	getSubset( material ) {

		return this.ifc.getSubset( this.modelID, material );

	}

	removeSubset( scene, material ) {

		this.ifc.removeSubset( this.modelID, scene, material );

	}

	createSubset( config ) {

		const modelConfig = {
			...config,
			modelID: this.modelID,
		};
		return this.ifc.createSubset( modelConfig );

	}

}

class IFCManager {

	constructor() {

		this.state = {
			models: [],
			api: new IfcAPI(),
		};
		this.parser = new IFCParser( this.state );
		this.subsets = new SubsetManager( this.state );
		this.properties = new PropertyManager( this.state );
		this.types = new TypeManager( this.state );

	}

	async parse( buffer ) {

		const mesh = await this.parser.parse( buffer );
		this.types.getAllTypes();
		return new IFCModel( mesh, this );

	}

	setWasmPath( path ) {

		this.state.api.SetWasmPath( path );

	}

	setupThreeMeshBVH( computeBoundsTree, disposeBoundsTree, acceleratedRaycast ) {

		this.parser.initializeMeshBVH(
			computeBoundsTree,
			disposeBoundsTree,
			acceleratedRaycast
		);

	}

	close( modelID, scene ) {

		this.state.api.CloseModel( modelID );
		if ( scene ) scene.remove( this.state.models[ modelID ].mesh );
		delete this.state.models[ modelID ];

	}

	getExpressId( geometry, faceIndex ) {

		return this.properties.getExpressId( geometry, faceIndex );

	}

	getAllItemsOfType( modelID, type, verbose ) {

		return this.properties.getAllItemsOfType( modelID, type, verbose );

	}

	getItemProperties( modelID, id, recursive = false ) {

		return this.properties.getItemProperties( modelID, id, recursive );

	}

	getPropertySets( modelID, id, recursive = false ) {

		return this.properties.getPropertySets( modelID, id, recursive );

	}

	getTypeProperties( modelID, id, recursive = false ) {

		return this.properties.getTypeProperties( modelID, id, recursive );

	}

	getIfcType( modelID, id ) {

		const typeID = this.state.models[ modelID ].types[ id ];
		return IfcElements[ typeID.toString() ];

	}

	getSpatialStructure( modelID ) {

		return this.properties.getSpatialStructure( modelID );

	}

	getSubset( modelID, material ) {

		return this.subsets.getSubset( modelID, material );

	}

	removeSubset( modelID, scene, material ) {

		this.subsets.removeSubset( modelID, scene, material );

	}

	createSubset( config ) {

		return this.subsets.createSubset( config );

	}

}

class IFCLoader extends Loader {

	constructor( manager ) {

		super( manager );
		this.ifcManager = new IFCManager();

	}

	load( url, onLoad, onProgress, onError ) {

		const scope = this;
		const loader = new FileLoader( scope.manager );
		loader.setPath( scope.path );
		loader.setResponseType( 'arraybuffer' );
		loader.setRequestHeader( scope.requestHeader );
		loader.setWithCredentials( scope.withCredentials );
		loader.load(
			url,
			async function ( buffer ) {

				try {

					if ( typeof buffer == 'string' ) {

						throw new Error( 'IFC files must be given as a buffer!' );

					}

					onLoad( await scope.parse( buffer ) );

				} catch ( e ) {

					if ( onError ) {

						onError( e );

					} else {

						console.error( e );

					}

					scope.manager.itemError( url );

				}

			},
			onProgress,
			onError
		);

	}

	parse( buffer ) {

		return this.ifcManager.parse( buffer );

	}

}

export { IFCLoader };
//# sourceMappingURL=IFCLoader.js.map