@inweb/viewer-three 26.7.6 → 26.8.1

package/dist/plugins/loaders/IFCXLoader.module.js

@@ -1,95 +1,109 @@
 import { Loader as Loader$1, GLTFLoadingManager, ModelImpl, loaders } from "@inweb/viewer-three";
 
-import { Box3, Vector3, Group, Matrix4, Scene, PerspectiveCamera, BufferGeometry, BufferAttribute, MeshBasicMaterial, Mesh, LineBasicMaterial, Line, Color, Loader, FileLoader } from "three";
+import { Box3, Vector3, Scene, PerspectiveCamera, Group, Matrix4, BufferGeometry, BufferAttribute, MeshLambertMaterial, Mesh, LineBasicMaterial, Line, Float32BufferAttribute, MeshStandardMaterial, Color, Euler, PointsMaterial, Points, Loader, FileLoader } from "three";
+
+import { PCDLoader } from "three/examples/jsm/loaders/PCDLoader.js";
 
 const THREE = {
     Box3: Box3,
     BufferAttribute: BufferAttribute,
     BufferGeometry: BufferGeometry,
     Color: Color,
+    Euler: Euler,
+    Float32BufferAttribute: Float32BufferAttribute,
     Group: Group,
     Line: Line,
     LineBasicMaterial: LineBasicMaterial,
     Matrix4: Matrix4,
     Mesh: Mesh,
-    MeshBasicMaterial: MeshBasicMaterial,
+    MeshLambertMaterial: MeshLambertMaterial,
+    MeshStandardMaterial: MeshStandardMaterial,
+    Points: Points,
+    PointsMaterial: PointsMaterial,
     PerspectiveCamera: PerspectiveCamera,
     Scene: Scene,
     Vector3: Vector3
 };
 
-function getChildByName(root, childName, skip = 0) {
-    let fragments = childName.replace(/^<\/|^\/|>$/g, "").split("/");
-    for (let i = 0; i < skip; ++i) {
-        fragments.shift();
-    }
-    let start = root;
-    while (fragments.length && start && start.children) {
-        let f = fragments.shift();
-        start = start.children.find((i => i.name.split("/").reverse()[0] === f));
+var StackedLayerProvider = class {
+    providers;
+    constructor(providers) {
+        this.providers = providers;
     }
-    if (fragments.length == 0) {
-        return start;
+    async GetLayerByURI(uri) {
+        let errorStack = [];
+        for (let provider of this.providers) {
+            let layer = await provider.GetLayerByURI(uri);
+            if (!(layer instanceof Error)) {
+                return layer;
+            } else {
+                errorStack.push(layer);
+            }
+        }
+        return new Error(JSON.stringify(errorStack));
     }
-}
+};
 
-function GetNode(node, path) {
-    if (path === "") return node;
-    let parts = path.split("/");
-    let child = node.children.get(parts[0]);
-    if (child) {
-        if (parts.length === 1) {
-            return child;
+var InMemoryLayerProvider = class {
+    layers;
+    constructor() {
+        this.layers = new Map;
+    }
+    GetLayerByURI(uri) {
+        if (!this.layers.has(uri)) {
+            return new Error(`File with uri "${uri}" not found`);
         }
-        return GetNode(child, GetTail(path));
-    } else {
-        return null;
+        return Promise.resolve(this.layers.get(uri));
     }
-}
-
-function GetHead(path) {
-    return path.split("/")[0];
-}
-
-function GetTail(path) {
-    let parts = path.split("/");
-    parts.shift();
-    return parts.join("/");
-}
+    add(file) {
+        if (this.layers.has(file.header.id)) {
+            throw new Error(`Inserting file with duplicate ID "${file.header.id}"`);
+        }
+        this.layers.set(file.header.id, file);
+        return this;
+    }
+    AddAll(files) {
+        files.forEach((f => this.add(f)));
+        return this;
+    }
+};
 
-function MakeNode(node) {
-    return {
-        node: node,
-        children: new Map,
-        attributes: new Map
-    };
+function log(bla) {
+    {
+        console.log(`${JSON.stringify(arguments)}`);
+    }
 }
 
-function ConvertToCompositionNode(path, inputNodes) {
-    let compositionNode = {
-        path: path,
-        children: {},
-        inherits: {},
-        attributes: {}
-    };
-    inputNodes.forEach((node => {
-        Object.keys(node.children).forEach((childName => {
-            compositionNode.children[childName] = node.children[childName];
-        }));
-        Object.keys(node.inherits).forEach((inheritName => {
-            let ih = node.inherits[inheritName];
-            if (ih === null) {
-                delete compositionNode.inherits[inheritName];
-            } else {
-                compositionNode.inherits[inheritName] = ih;
+var FetchLayerProvider = class {
+    layers;
+    constructor() {
+        this.layers = new Map;
+    }
+    async FetchJson(url) {
+        let result = await fetch(url);
+        if (!result.ok) {
+            return new Error(`Failed to fetch ${url}: ${result.status}`);
+        }
+        try {
+            return await result.json();
+        } catch (e) {
+            log(url);
+            return new Error(`Failed to parse json at ${url}: ${e}`);
+        }
+    }
+    async GetLayerByURI(uri) {
+        if (!this.layers.has(uri)) {
+            let fetched = await this.FetchJson(uri);
+            if (fetched instanceof Error) {
+                return new Error(`File with id "${uri}" not found`);
             }
-        }));
-        Object.keys(node.attributes).forEach((attrName => {
-            compositionNode.attributes[attrName] = node.attributes[attrName];
-        }));
-    }));
-    return compositionNode;
-}
+            let file = fetched;
+            this.layers.set(uri, file);
+            return file;
+        }
+        return this.layers.get(uri);
+    }
+};
 
 function MMSet(map, key, value) {
     if (map.has(key)) {
@@ -99,6 +113,8 @@ function MMSet(map, key, value) {
     }
 }
 
+var CycleError = class extends Error {};
+
 function FindRootsOrCycles(nodes) {
     let dependencies = new Map;
     let dependents = new Map;
@@ -139,22 +155,78 @@ function FindRootsOrCycles(nodes) {
     return roots;
 }
 
-function ConvertNodes(input) {
+function GetHead(path) {
+    return path.split("/")[0];
+}
+
+function GetTail(path) {
+    let parts = path.split("/");
+    parts.shift();
+    return parts.join("/");
+}
+
+function MakePostCompositionNode(node) {
+    return {
+        node: node,
+        children: new Map,
+        attributes: new Map
+    };
+}
+
+function GetChildNodeWithPath(node, path) {
+    if (path === "") return node;
+    let parts = path.split("/");
+    let child = node.children.get(parts[0]);
+    if (child) {
+        if (parts.length === 1) {
+            return child;
+        }
+        return GetChildNodeWithPath(child, GetTail(path));
+    } else {
+        return null;
+    }
+}
+
+function FlattenPathToPreCompositionNode(path, inputNodes) {
+    let compositionNode = {
+        path: path,
+        children: {},
+        inherits: {},
+        attributes: {}
+    };
+    inputNodes.forEach((node => {
+        Object.keys(node.children).forEach((childName => {
+            compositionNode.children[childName] = node.children[childName];
+        }));
+        Object.keys(node.inherits).forEach((inheritName => {
+            let ih = node.inherits[inheritName];
+            if (ih === null) {
+                delete compositionNode.inherits[inheritName];
+            } else {
+                compositionNode.inherits[inheritName] = ih;
+            }
+        }));
+        Object.keys(node.attributes).forEach((attrName => {
+            compositionNode.attributes[attrName] = node.attributes[attrName];
+        }));
+    }));
+    return compositionNode;
+}
+
+function FlattenCompositionInput(input) {
     let compositionNodes = new Map;
     for (let [path, inputNodes] of input) {
-        compositionNodes.set(path, ConvertToCompositionNode(path, inputNodes));
+        compositionNodes.set(path, FlattenPathToPreCompositionNode(path, inputNodes));
     }
     return compositionNodes;
 }
 
-var CycleError = class extends Error {};
-
 function ExpandFirstRootInInput(nodes) {
     let roots = FindRootsOrCycles(nodes);
     if (!roots) {
         throw new CycleError;
     }
-    return ExpandNewNode([ ...roots.values() ][0], nodes);
+    return ComposeNodeFromPath([ ...roots.values() ][0], nodes);
 }
 
 function CreateArtificialRoot(nodes) {
@@ -168,31 +240,31 @@ function CreateArtificialRoot(nodes) {
         children: new Map
     };
     roots.forEach((root => {
-        pseudoRoot.children.set(root, ExpandNewNode(root, nodes));
+        pseudoRoot.children.set(root, ComposeNodeFromPath(root, nodes));
     }));
     return pseudoRoot;
 }
 
-function ExpandNewNode(node, nodes) {
-    return ExpandNode(node, MakeNode(node), nodes);
+function ComposeNodeFromPath(path, preCompositionNodes) {
+    return ComposeNode(path, MakePostCompositionNode(path), preCompositionNodes);
 }
 
-function ExpandNode(path, node, nodes) {
-    let input = nodes.get(path);
-    if (input) {
-        AddDataFromInput(input, node, nodes);
+function ComposeNode(path, postCompositionNode, preCompositionNodes) {
+    let preCompositionNode = preCompositionNodes.get(path);
+    if (preCompositionNode) {
+        AddDataFromPreComposition(preCompositionNode, postCompositionNode, preCompositionNodes);
     }
-    node.children.forEach(((child, name) => {
-        ExpandNode(`${path}/${name}`, child, nodes);
+    postCompositionNode.children.forEach(((child, name) => {
+        ComposeNode(`${path}/${name}`, child, preCompositionNodes);
     }));
-    return node;
+    return postCompositionNode;
 }
 
-function AddDataFromInput(input, node, nodes) {
-    Object.values(input.inherits).forEach((inherit => {
-        let classNode = ExpandNewNode(GetHead(inherit), nodes);
-        let subnode = GetNode(classNode, GetTail(inherit));
-        if (!subnode) throw new Error(`Unknown node ${inherit}`);
+function AddDataFromPreComposition(input, node, nodes) {
+    Object.values(input.inherits).forEach((inheritPath => {
+        let classNode = ComposeNodeFromPath(GetHead(inheritPath), nodes);
+        let subnode = GetChildNodeWithPath(classNode, GetTail(inheritPath));
+        if (!subnode) throw new Error(`Unknown node ${inheritPath}`);
         subnode.children.forEach(((child, childName) => {
             node.children.set(childName, child);
         }));
@@ -202,8 +274,8 @@ function AddDataFromInput(input, node, nodes) {
     }));
     Object.entries(input.children).forEach((([childName, child]) => {
         if (child !== null) {
-            let classNode = ExpandNewNode(GetHead(child), nodes);
-            let subnode = GetNode(classNode, GetTail(child));
+            let classNode = ComposeNodeFromPath(GetHead(child), nodes);
+            let subnode = GetChildNodeWithPath(classNode, GetTail(child));
             if (!subnode) throw new Error(`Unknown node ${child}`);
             node.children.set(childName, subnode);
         } else {
@@ -215,31 +287,12 @@ function AddDataFromInput(input, node, nodes) {
     }));
 }
 
-function MMSet2(map, key, value) {
-    if (map.has(key)) {
-        map.get(key)?.push(value);
-    } else {
-        map.set(key, [ value ]);
-    }
-}
-
-function ToInputNodes(data) {
-    let inputNodes = new Map;
-    data.forEach((ifcxNode => {
-        let node = {
-            path: ifcxNode.path,
-            children: ifcxNode.children ? ifcxNode.children : {},
-            inherits: ifcxNode.inherits ? ifcxNode.inherits : {},
-            attributes: ifcxNode.attributes ? ifcxNode.attributes : {}
-        };
-        MMSet2(inputNodes, node.path, node);
-    }));
-    return inputNodes;
-}
-
 var SchemaValidationError = class extends Error {};
 
 function ValidateAttributeValue(desc, value, path, schemas) {
+    if (desc.optional && value === undefined) {
+        return;
+    }
     if (desc.inherits) {
         desc.inherits.forEach((inheritedSchemaID => {
             let inheritedSchema = schemas[inheritedSchemaID];
@@ -277,7 +330,7 @@ function ValidateAttributeValue(desc, value, path, schemas) {
         if (typeof value !== "number") {
             throw new SchemaValidationError(`Expected "${value}" to be of type real`);
         }
-    } else if (desc.dataType === "Relation") {
+    } else if (desc.dataType === "Reference") {
         if (typeof value !== "string") {
             throw new SchemaValidationError(`Expected "${value}" to be of type string`);
         }
@@ -287,7 +340,10 @@ function ValidateAttributeValue(desc, value, path, schemas) {
         }
         if (desc.objectRestrictions) {
             Object.keys(desc.objectRestrictions.values).forEach((key => {
-                if (!Object.hasOwn(value, key)) {
+                let optional = desc.objectRestrictions.values[key].optional;
+                let hasOwn = Object.hasOwn(value, key);
+                if (optional && !hasOwn) return;
+                if (!hasOwn) {
                     throw new SchemaValidationError(`Expected "${value}" to have key ${key}`);
                 }
                 ValidateAttributeValue(desc.objectRestrictions.values[key], value[key], path + "." + key, schemas);
@@ -307,7 +363,7 @@ function ValidateAttributeValue(desc, value, path, schemas) {
 
 function Validate(schemas, inputNodes) {
     inputNodes.forEach((node => {
-        Object.keys(node.attributes).forEach((schemaID => {
+        Object.keys(node.attributes).filter((v => !v.startsWith("__internal"))).forEach((schemaID => {
             if (!schemas[schemaID]) {
                 throw new SchemaValidationError(`Missing schema "${schemaID}" referenced by ["${node.path}"].attributes`);
             }
@@ -326,9 +382,23 @@ function Validate(schemas, inputNodes) {
     }));
 }
 
-function LoadIfcxFile(file, checkSchemas = true, createArtificialRoot = false) {
+function ToInputNodes(data) {
+    let inputNodes = new Map;
+    data.forEach((ifcxNode => {
+        let node = {
+            path: ifcxNode.path,
+            children: ifcxNode.children ? ifcxNode.children : {},
+            inherits: ifcxNode.inherits ? ifcxNode.inherits : {},
+            attributes: ifcxNode.attributes ? ifcxNode.attributes : {}
+        };
+        MMSet(inputNodes, node.path, node);
+    }));
+    return inputNodes;
+}
+
+function LoadIfcxFile(file, checkSchemas = true, createArtificialRoot = true) {
     let inputNodes = ToInputNodes(file.data);
-    let compositionNodes = ConvertNodes(inputNodes);
+    let compositionNodes = FlattenCompositionInput(inputNodes);
     try {
         if (checkSchemas) {
             Validate(file.schemas, compositionNodes);
@@ -344,6 +414,9 @@ function LoadIfcxFile(file, checkSchemas = true, createArtificialRoot = false) {
 }
 
 function Federate(files) {
+    if (files.length === 0) {
+        throw new Error(`Trying to federate empty set of files`);
+    }
     let result = {
         header: files[0].header,
         schemas: {},
@@ -395,6 +468,7 @@ function Collapse(nodes, deleteEmpty = false) {
 function Prune(file, deleteEmpty = false) {
     let result = {
         header: file.header,
+        imports: [],
         schemas: file.schemas,
         data: []
     };
@@ -411,6 +485,97 @@ function Prune(file, deleteEmpty = false) {
     return result;
 }
 
+var IfcxLayerStack = class {
+    layers;
+    tree;
+    schemas;
+    federated;
+    constructor(layers) {
+        this.layers = layers;
+        this.Compose();
+    }
+    GetLayerIds() {
+        return this.layers.map((l => l.header.id));
+    }
+    Compose() {
+        this.federated = Federate(this.layers);
+        this.schemas = this.federated.schemas;
+        this.tree = LoadIfcxFile(this.federated);
+    }
+    GetFullTree() {
+        this.Compose();
+        return this.tree;
+    }
+    GetFederatedLayer() {
+        return this.federated;
+    }
+    GetSchemas() {
+        return this.schemas;
+    }
+};
+
+var IfcxLayerStackBuilder = class {
+    provider;
+    mainLayerId=null;
+    constructor(provider) {
+        this.provider = provider;
+    }
+    FromId(id) {
+        this.mainLayerId = id;
+        return this;
+    }
+    async Build() {
+        if (!this.mainLayerId) throw new Error(`no main layer ID specified`);
+        let layers = await this.BuildLayerSet(this.mainLayerId);
+        if (layers instanceof Error) {
+            return layers;
+        }
+        try {
+            return new IfcxLayerStack(layers);
+        } catch (e) {
+            return e;
+        }
+    }
+    async SatisfyDependencies(activeLayer, placed, orderedLayers) {
+        let pending = [];
+        for (const impt of activeLayer.imports) {
+            if (!placed.has(impt.uri)) {
+                let layer = await this.provider.GetLayerByURI(impt.uri);
+                if (layer instanceof Error) {
+                    return layer;
+                }
+                pending.push(layer);
+                placed.set(impt.uri, true);
+            }
+        }
+        let temp = [];
+        for (const layer of pending) {
+            temp.push(layer);
+            let layers = await this.SatisfyDependencies(layer, placed, orderedLayers);
+            if (layers instanceof Error) {
+                return layers;
+            }
+            temp.push(...layers);
+        }
+        temp.forEach((t => orderedLayers.push(t)));
+        return temp;
+    }
+    async BuildLayerSet(activeLayerID) {
+        let activeLayer = await this.provider.GetLayerByURI(activeLayerID);
+        if (activeLayer instanceof Error) {
+            return activeLayer;
+        }
+        let layerSet = [ activeLayer ];
+        let placed = new Map;
+        placed.set(activeLayer.header.id, true);
+        let result = await this.SatisfyDependencies(activeLayer, placed, layerSet);
+        if (result instanceof Error) {
+            return result;
+        }
+        return layerSet;
+    }
+};
+
 function TreeNodeToComposedObject(path, node, schemas) {
     let co = {
         name: path,
@@ -445,10 +610,28 @@ function TreeNodeToComposedObject(path, node, schemas) {
     return co;
 }
 
-function compose3(files) {
-    let federated = Federate(files);
-    let tree = LoadIfcxFile(federated, true, true);
-    return TreeNodeToComposedObject("", tree, federated.schemas);
+async function compose3(files) {
+    let userDefinedOrder = {
+        header: {
+            ...files[0].header
+        },
+        imports: files.map((f => ({
+            uri: f.header.id
+        }))),
+        schemas: {},
+        data: []
+    };
+    userDefinedOrder.header.id = "USER_DEF";
+    let provider = new StackedLayerProvider([ (new InMemoryLayerProvider).AddAll([ userDefinedOrder, ...files ]), new FetchLayerProvider ]);
+    let layerStack = await new IfcxLayerStackBuilder(provider).FromId(userDefinedOrder.header.id).Build();
+    if (layerStack instanceof Error) {
+        throw layerStack;
+    }
+    layerStack.GetFederatedLayer().data.forEach(((n, i) => {
+        n.attributes = n.attributes || {};
+        n.attributes[`__internal_${i}`] = n.path;
+    }));
+    return TreeNodeToComposedObject("", layerStack.GetFullTree(), layerStack.GetSchemas());
 }
 
 var scene;
@@ -459,6 +642,12 @@ var datas = [];
 
 var autoCamera = true;
 
+var objectMap = {};
+
+var primMap = {};
+
+var envMap;
+
 function init() {
     scene = new THREE.Scene;
     camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, .1, 100);
@@ -474,32 +663,74 @@ function HasAttr(node, attrName) {
     return !!node.attributes[attrName];
 }
 
-function createMaterialFromParent(parent, root) {
-    let reference = parent.attributes["usd::usdshade::materialbindingapi::material::binding"];
+function tryCreateMeshGltfMaterial(path) {
+    for (let p of path) {
+        if (!p.attributes) {
+            continue;
+        }
+        const pbrMetallicRoughness = p.attributes["gltf::material::pbrMetallicRoughness"];
+        const normalTexture = p.attributes["gltf::material::normalTexture"];
+        const occlusionTexture = p.attributes["gltf::material::occlusionTexture"];
+        const emissiveTexture = p.attributes["gltf::material::emissiveTexture"];
+        const emissiveFactor = p.attributes["gltf::material::emissiveFactor"];
+        const alphaMode = p.attributes["gltf::material::alphaMode"];
+        const alphaCutoff = p.attributes["gltf::material::alphaCutoff"];
+        const doubleSided = p.attributes["gltf::material::doubleSided"];
+        if (!pbrMetallicRoughness && !normalTexture && !occlusionTexture && !emissiveTexture && !emissiveFactor && !alphaMode && !alphaCutoff && !doubleSided) {
+            continue;
+        }
+        let material = new THREE.MeshStandardMaterial;
+        material.color = new THREE.Color(1, 1, 1);
+        material.metalness = 1;
+        material.roughness = 1;
+        if (pbrMetallicRoughness) {
+            let baseColorFactor = pbrMetallicRoughness["baseColorFactor"];
+            if (baseColorFactor) {
+                material.color = new THREE.Color(baseColorFactor[0], baseColorFactor[1], baseColorFactor[2]);
+            }
+            let metallicFactor = pbrMetallicRoughness["metallicFactor"];
+            if (metallicFactor !== undefined) {
+                material.metalness = metallicFactor;
+            }
+            let roughnessFactor = pbrMetallicRoughness["roughnessFactor"];
+            if (roughnessFactor !== undefined) {
+                material.roughness = roughnessFactor;
+            }
+        }
+        material.envMap = envMap;
+        material.needsUpdate = true;
+        material.envMapRotation = new THREE.Euler(.5 * Math.PI, 0, 0);
+        return material;
+    }
+    return undefined;
+}
+
+function createMaterialFromParent(path) {
     let material = {
         color: new THREE.Color(.6, .6, .6),
         transparent: false,
         opacity: 1
     };
-    if (reference) {
-        const materialNode = getChildByName(root, reference.ref);
-        if (materialNode) {
-            let color = materialNode?.attributes["bsi::presentation::diffuseColor"];
+    for (let p of path) {
+        const color = p.attributes ? p.attributes["bsi::ifc::presentation::diffuseColor"] : null;
+        if (color) {
             material.color = new THREE.Color(...color);
-            if (materialNode?.attributes["bsi::presentation::opacity"]) {
+            const opacity = p.attributes["bsi::ifc::presentation::opacity"];
+            if (opacity) {
                 material.transparent = true;
-                material.opacity = materialNode.attributes["bsi::presentation::opacity"];
+                material.opacity = opacity;
             }
+            break;
         }
     }
     return material;
 }
 
-function createCurveFromJson(node, parent, root) {
-    let points = new Float32Array(node.attributes["usd::usdgeom::basiscurves::points"].flat());
+function createCurveFromJson(path) {
+    let points = new Float32Array(path[0].attributes["usd::usdgeom::basiscurves::points"].flat());
     const geometry = new THREE.BufferGeometry;
     geometry.setAttribute("position", new THREE.BufferAttribute(points, 3));
-    const material = createMaterialFromParent(parent, root);
+    const material = createMaterialFromParent(path);
     let lineMaterial = new THREE.LineBasicMaterial({
         ...material
     });
@@ -507,33 +738,125 @@ function createCurveFromJson(node, parent, root) {
     return new THREE.Line(geometry, lineMaterial);
 }
 
-function createMeshFromJson(node, parent, root) {
-    let points = new Float32Array(node.attributes["usd::usdgeom::mesh::points"].flat());
-    let indices = new Uint16Array(node.attributes["usd::usdgeom::mesh::faceVertexIndices"]);
+function createMeshFromJson(path) {
+    let points = new Float32Array(path[0].attributes["usd::usdgeom::mesh::points"].flat());
+    let indices = new Uint16Array(path[0].attributes["usd::usdgeom::mesh::faceVertexIndices"]);
     const geometry = new THREE.BufferGeometry;
     geometry.setAttribute("position", new THREE.BufferAttribute(points, 3));
     geometry.setIndex(new THREE.BufferAttribute(indices, 1));
     geometry.computeVertexNormals();
-    const material = createMaterialFromParent(parent, root);
-    let meshMaterial = new THREE.MeshBasicMaterial({
-        ...material
-    });
+    var meshMaterial;
+    let gltfPbrMaterial = tryCreateMeshGltfMaterial(path);
+    if (gltfPbrMaterial) {
+        meshMaterial = gltfPbrMaterial;
+    } else {
+        const m = createMaterialFromParent(path);
+        meshMaterial = new THREE.MeshLambertMaterial({
+            ...m
+        });
+    }
     return new THREE.Mesh(geometry, meshMaterial);
 }
 
-function traverseTree(node, parent, root, parentNode = undefined) {
+function createPointsFromJsonPcdBase64(path) {
+    const base64_string = path[0].attributes["pcd::base64"];
+    const decoded = atob(base64_string);
+    const len = decoded.length;
+    const bytes = new Uint8Array(len);
+    for (let i = 0; i < len; i++) {
+        bytes[i] = decoded.charCodeAt(i);
+    }
+    const loader = new PCDLoader;
+    const points = loader.parse(bytes.buffer);
+    points.material.sizeAttenuation = false;
+    points.material.size = 2;
+    return points;
+}
+
+function createPoints(geometry, withColors) {
+    const material = new THREE.PointsMaterial;
+    material.sizeAttenuation = false;
+    material.fog = true;
+    material.size = 5;
+    material.color = new THREE.Color(withColors ? 16777215 : 0);
+    if (withColors) {
+        material.vertexColors = true;
+    }
+    return new THREE.Points(geometry, material);
+}
+
+function createPointsFromJsonArray(path) {
+    const geometry = new THREE.BufferGeometry;
+    const positions = new Float32Array(path[0].attributes["points::array::positions"].flat());
+    geometry.setAttribute("position", new THREE.Float32BufferAttribute(positions, 3));
+    const colors = path[0].attributes["points::array::colors"];
+    if (colors) {
+        const colors_ = new Float32Array(colors.flat());
+        geometry.setAttribute("color", new THREE.Float32BufferAttribute(colors_, 3));
+    }
+    return createPoints(geometry, colors);
+}
+
+function base64ToArrayBuffer(str) {
+    let binary;
+    try {
+        binary = atob(str);
+    } catch (e) {
+        throw new Error("base64 encoded string is invalid");
+    }
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; ++i) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes.buffer;
+}
+
+function createPointsFromJsonPositionBase64(path) {
+    const geometry = new THREE.BufferGeometry;
+    const positions_base64 = path[0].attributes["points::base64::positions"];
+    const positions_bytes = base64ToArrayBuffer(positions_base64);
+    if (!positions_bytes) {
+        return null;
+    }
+    const positions = new Float32Array(positions_bytes);
+    geometry.setAttribute("position", new THREE.Float32BufferAttribute(positions, 3));
+    const colors_base64 = path[0].attributes["points::base64::colors"];
+    if (colors_base64) {
+        const colors_bytes = base64ToArrayBuffer(colors_base64);
+        if (colors_bytes) {
+            const colors = new Float32Array(colors_bytes);
+            geometry.setAttribute("color", new THREE.Float32BufferAttribute(colors, 3));
+        }
+    }
+    return createPoints(geometry, colors_base64);
+}
+
+function traverseTree(path, parent, pathMapping) {
+    const node = path[0];
     let elem = new THREE.Group;
     if (HasAttr(node, "usd::usdgeom::visibility::visibility")) {
         if (node.attributes["usd::usdgeom::visibility::visibility"] === "invisible") {
             return;
         }
     } else if (HasAttr(node, "usd::usdgeom::mesh::points")) {
-        elem = createMeshFromJson(node, parentNode, root);
+        elem = createMeshFromJson(path);
     } else if (HasAttr(node, "usd::usdgeom::basiscurves::points")) {
-        elem = createCurveFromJson(node, parentNode, root);
+        elem = createCurveFromJson(path);
+    } else if (HasAttr(node, "pcd::base64")) {
+        elem = createPointsFromJsonPcdBase64(path);
+    } else if (HasAttr(node, "points::array::positions")) {
+        elem = createPointsFromJsonArray(path);
+    } else if (HasAttr(node, "points::base64::positions")) {
+        elem = createPointsFromJsonPositionBase64(path);
+    }
+    objectMap[node.name] = elem;
+    primMap[node.name] = node;
+    elem.userData.path = node.name;
+    for (let path2 of Object.entries(node.attributes || {}).filter((([k, _]) => k.startsWith("__internal_"))).map((([_, v]) => v))) {
+        (pathMapping[String(path2)] = pathMapping[String(path2)] || []).push(node.name);
     }
     parent.add(elem);
-    if (node !== root) {
+    if (path.length > 1) {
         elem.matrixAutoUpdate = false;
         let matrixNode = node.attributes && node.attributes["usd::xformop::transform"] ? node.attributes["usd::xformop::transform"].flat() : null;
         if (matrixNode) {
@@ -543,24 +866,30 @@ function traverseTree(node, parent, root, parentNode = undefined) {
             elem.matrix = matrix;
         }
     }
-    (node.children || []).forEach((child => traverseTree(child, elem || parent, root, node)));
+    (node.children || []).forEach((child => traverseTree([ child, ...path ], elem || parent, pathMapping)));
 }
 
-function composeAndRender() {
+async function composeAndRender() {
     if (scene) {
         scene.children = [];
     }
+    objectMap = {};
+    primMap = {};
     if (datas.length === 0) {
         return;
     }
     let tree = null;
     let dataArray = datas.map((arr => arr[1]));
-    tree = compose3(dataArray);
+    tree = await compose3(dataArray);
     if (!tree) {
         console.error("No result from composition");
         return;
     }
-    traverseTree(tree, scene || init(), tree);
+    if (!scene) {
+        init();
+    }
+    let pathMapping = {};
+    traverseTree([ tree ], scene, pathMapping);
     if (autoCamera) {
         const boundingBox = new THREE.Box3;
         boundingBox.setFromObject(scene);
@@ -575,9 +904,9 @@ function composeAndRender() {
     }
 }
 
-function parse(m, name) {
+async function parse(m, name) {
     datas.push([ name, m ]);
-    composeAndRender();
+    await composeAndRender();
     return scene;
 }
 
@@ -608,13 +937,7 @@ class IFCXLoader extends Loader {
         loader.load(url, (json => this.parse(json, _onLoad, _onError)), onProgress, onError);
     }
     parse(json, onLoad, onError) {
-        try {
-            onLoad(parse(json));
-        } catch (e) {
-            onError(e);
-        } finally {
-            clear();
-        }
+        parse(json).then((scene => onLoad(scene))).catch((err => onError(err))).finally((() => clear()));
     }
 }
 
@@ -688,7 +1011,7 @@ class IFCXCloudLoader extends Loader$1 {
         if (!this.viewer.scene) return this;
         const textDecoder = new TextDecoder;
         const json = JSON.parse(textDecoder.decode(arrayBuffer));
-        const scene = parse(json);
+        const scene = await parse(json);
         clear();
         let handle = 0;
         scene.traverse((object => {