threejs-viewer-26

// Add IfcLoader.js
import * as WebIFC from 'https://unpkg.com/web-ifc/web-ifc-api.js';

class IfcLoader extends THREE.Loader {
    constructor(manager) {
        super(manager);

        this.ifcAPI = new WebIFC.IfcAPI();
        this.ifcAPI.Init();
        this.modelID = null;
        this.geometryByMaterials = {};
    }

    load(url, onLoad, onProgress, onError) {
        const loader = new THREE.FileLoader(this.manager);
        loader.setPath(this.path);
        loader.setResponseType('arraybuffer');
        loader.setRequestHeader(this.requestHeader);
        loader.setWithCredentials(this.withCredentials);
        loader.load(
            url,
            (buffer) => {
                try {
                    onLoad(this.parse(buffer));
                } catch (e) {
                    if (onError) {
                        onError(e);
                    } else {
                        console.error(e);
                    }

                    this.manager.itemError(url);
                }
            },
            onProgress,
            onError
        );
    }

    getIfcItemInformation(expressID) {
        return this.ifcAPI.GetLine(this.modelID, expressID);
    }

    parse(buffer) {
        const ifcAPI = this.ifcAPI;
        const materials = this.geometryByMaterials;
        var data = new Uint8Array(buffer);
        this.modelID = ifcAPI.OpenModel('example.ifc', data);
        return loadAllGeometry(this.modelID);

        function loadAllGeometry(modelID) {
            var flatMeshes = getFlatMeshes(modelID);
            var mainObject = new THREE.Object3D();
            for (var i = 0; i < flatMeshes.size(); i++) {
                var placedGeometries = flatMeshes.get(i).geometries;
                for (var j = 0; j < placedGeometries.size(); j++) {
                    const mesh = getPlacedGeometry(modelID, placedGeometries.get(j))
                    mesh.expressID = flatMeshes.get(i).expressID;
                    mainObject.add(mesh);
                }
            }
            return mainObject;
        }

        function getFlatMeshes(modelID) {
            var flatMeshes = ifcAPI.LoadAllGeometry(modelID);
            return flatMeshes;
        }

        function getPlacedGeometry(modelID, placedGeometry) {
            var geometry = getBufferGeometry(modelID, placedGeometry);
            var material = getMaterial(placedGeometry.color);
            var mesh = new THREE.Mesh(geometry, material);
            mesh.expressID = placedGeometry.expressID;
            mesh.matrix = getMeshMatrix(placedGeometry.flatTransformation);
            mesh.matrixAutoUpdate = false;
            return mesh;
        }

        function getBufferGeometry(modelID, placedGeometry) {
            var geometry = ifcAPI.GetGeometry(modelID, placedGeometry.geometryExpressID);
            var verts = ifcAPI.GetVertexArray(geometry.GetVertexData(), geometry.GetVertexDataSize());
            var indices = ifcAPI.GetIndexArray(geometry.GetIndexData(), geometry.GetIndexDataSize());
            var bufferGeometry = ifcGeometryToBuffer(verts, indices);
            return bufferGeometry;
        }

        function getMeshMatrix(matrix) {
            var mat = new THREE.Matrix4();
            mat.fromArray(matrix);
            return mat;
        }

        function ifcGeometryToBuffer(vertexData, indexData) {
            var geometry = new THREE.BufferGeometry();
            var { vertices, normals } = extractVertexData(vertexData);
            geometry.addAttribute('position', new THREE.BufferAttribute(new Float32Array(vertices), 3));
            geometry.addAttribute('normal', new THREE.BufferAttribute(new Float32Array(normals), 3));
            geometry.setIndex(new THREE.BufferAttribute(indexData, 1));
            return geometry;
        }

        function extractVertexData(vertexData) {
            var vertices = [],
                normals = [];
            var isNormalData = false;
            for (var 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 };
        }

        function getMaterial(color) {
            var id = `${color.x}${color.y}${color.z}${color.w}`;
            if (!materials[id]) {
                var col = new THREE.Color(color.x, color.y, color.z);
                var newMaterial = new THREE.MeshPhongMaterial({ color: col, side: THREE.DoubleSide });
                newMaterial.transparent = color.w !== 1;
                if (newMaterial.transparent) newMaterial.opacity = color.w;
                materials[id] = newMaterial;
            }
            return materials[id];
        }
    }
}

window.IfcLoader = IfcLoader;