@inweb/viewer-three 26.8.0 → 26.8.2

package/plugins/loaders/IFCX/render.js

@@ -29,6 +29,7 @@
 // (C) buildingSMART International
 // published under MIT license
 
+/* eslint-disable lines-between-class-members */
 /* eslint-disable @typescript-eslint/no-unused-vars */
 /* eslint-disable prefer-const */
 /* eslint-disable no-useless-catch */
@@ -38,12 +39,18 @@ import {
   BufferAttribute,
   BufferGeometry,
   Color,
+  Euler,
+  Float32BufferAttribute,
   Group,
   Line,
   LineBasicMaterial,
   Matrix4,
   Mesh,
   MeshBasicMaterial,
+  MeshLambertMaterial,
+  MeshStandardMaterial,
+  Points,
+  PointsMaterial,
   PerspectiveCamera,
   Scene,
   Vector3,
@@ -54,88 +61,107 @@ const THREE = {
   BufferAttribute,
   BufferGeometry,
   Color,
+  Euler,
+  Float32BufferAttribute,
   Group,
   Line,
   LineBasicMaterial,
   Matrix4,
   Mesh,
   MeshBasicMaterial,
+  MeshLambertMaterial,
+  MeshStandardMaterial,
+  Points,
+  PointsMaterial,
   PerspectiveCamera,
   Scene,
   Vector3,
 };
 
-// composed-object.ts
-function getChildByName(root, childName, skip = 0) {
-  let fragments = childName.replace(/^<\/|^\/|>$/g, "").split("/");
-  for (let i = 0; i < skip; ++i) {
-    fragments.shift();
+// ifcx-core/layers/layer-providers.ts
+var StackedLayerProvider = class {
+  providers;
+  constructor(providers) {
+    this.providers = providers;
   }
-  let start = root;
-  while (fragments.length && start && start.children) {
-    // console.log(start, fragments[0]);
-    let f = fragments.shift();
-    start = start.children.find((i) => i.name.split("/").reverse()[0] === f);
+  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));
+  }
+};
+var InMemoryLayerProvider = class {
+  layers;
+  constructor() {
+    this.layers = /* @__PURE__ */ new Map();
+  }
+  GetLayerByURI(uri) {
+    if (!this.layers.has(uri)) {
+      return new Error(`File with uri "${uri}" not found`);
+    }
+    return Promise.resolve(this.layers.get(uri));
   }
-  if (fragments.length == 0) {
-    return start;
+  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;
+  }
+};
+
+// ifcx-core/util/log.ts
+var LOG_ENABLED = true;
+function log(bla) {
+  if (LOG_ENABLED) {
+    console.log(`${JSON.stringify(arguments)}`);
   }
 }
 
-// compose-alpha.ts
-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;
+// ifcx-core/layers/fetch-layer-provider.ts
+var FetchLayerProvider = class {
+  layers;
+  constructor() {
+    this.layers = /* @__PURE__ */ 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}`);
     }
-    return GetNode(child, GetTail(path));
-  } else {
-    return null;
   }
-}
-function GetHead(path) {
-  return path.split("/")[0];
-}
-function GetTail(path) {
-  let parts = path.split("/");
-  parts.shift();
-  return parts.join("/");
-}
-function MakeNode(node) {
-  return {
-    node,
-    children: /* @__PURE__ */ new Map(),
-    attributes: /* @__PURE__ */ new Map(),
-  };
-}
-function ConvertToCompositionNode(path, inputNodes) {
-  let compositionNode = {
-    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;
+  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);
+  }
+};
+
+// ifcx-core/util/mm.ts
 function MMSet(map, key, value) {
   if (map.has(key)) {
     map.get(key)?.push(value);
@@ -143,6 +169,9 @@ function MMSet(map, key, value) {
     map.set(key, [value]);
   }
 }
+
+// ifcx-core/composition/cycles.ts
+var CycleError = class extends Error {};
 function FindRootsOrCycles(nodes) {
   let dependencies = /* @__PURE__ */ new Map();
   let dependents = /* @__PURE__ */ new Map();
@@ -182,20 +211,78 @@ function FindRootsOrCycles(nodes) {
   }
   return roots;
 }
-function ConvertNodes(input) {
+
+// ifcx-core/composition/path.ts
+function GetHead(path) {
+  return path.split("/")[0];
+}
+function GetTail(path) {
+  let parts = path.split("/");
+  parts.shift();
+  return parts.join("/");
+}
+
+// ifcx-core/composition/node.ts
+function MakePostCompositionNode(node) {
+  return {
+    node,
+    children: /* @__PURE__ */ new Map(),
+    attributes: /* @__PURE__ */ 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;
+  }
+}
+
+// ifcx-core/composition/compose.ts
+function FlattenPathToPreCompositionNode(path, inputNodes) {
+  let compositionNode = {
+    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 = /* @__PURE__ */ 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) {
   let roots = FindRootsOrCycles(nodes);
@@ -208,28 +295,28 @@ function CreateArtificialRoot(nodes) {
     children: /* @__PURE__ */ 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);
     });
@@ -239,8 +326,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 {
@@ -252,29 +339,12 @@ function AddDataFromInput(input, node, nodes) {
   });
 }
 
-// workflow-alpha.ts
-function MMSet2(map, key, value) {
-  if (map.has(key)) {
-    map.get(key)?.push(value);
-  } else {
-    map.set(key, [value]);
-  }
-}
-function ToInputNodes(data) {
-  let inputNodes = /* @__PURE__ */ 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;
-}
+// ifcx-core/schema/schema-validation.ts
 var SchemaValidationError = class extends Error {};
 function ValidateAttributeValue(desc, value, path, schemas) {
+  if (desc.optional && value === void 0) {
+    return;
+  }
   if (desc.inherits) {
     desc.inherits.forEach((inheritedSchemaID) => {
       let inheritedSchema = schemas[inheritedSchemaID];
@@ -312,7 +382,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`);
     }
@@ -322,7 +392,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);
@@ -341,27 +414,46 @@ function ValidateAttributeValue(desc, value, path, schemas) {
 }
 function Validate(schemas, inputNodes) {
   inputNodes.forEach((node) => {
-    Object.keys(node.attributes).forEach((schemaID) => {
-      if (!schemas[schemaID]) {
-        throw new SchemaValidationError(`Missing schema "${schemaID}" referenced by ["${node.path}"].attributes`);
-      }
-      let schema = schemas[schemaID];
-      let value = node.attributes[schemaID];
-      try {
-        ValidateAttributeValue(schema.value, value, "", schemas);
-      } catch (e) {
-        if (e instanceof SchemaValidationError) {
-          throw new SchemaValidationError(`Error validating ["${node.path}"].attributes["${schemaID}"]: ${e.message}`);
-        } else {
-          throw e;
+    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`);
         }
-      }
-    });
+        let schema = schemas[schemaID];
+        let value = node.attributes[schemaID];
+        try {
+          ValidateAttributeValue(schema.value, value, "", schemas);
+        } catch (e) {
+          if (e instanceof SchemaValidationError) {
+            throw new SchemaValidationError(
+              `Error validating ["${node.path}"].attributes["${schemaID}"]: ${e.message}`
+            );
+          } else {
+            throw e;
+          }
+        }
+      });
+  });
+}
+
+// ifcx-core/workflows.ts
+function ToInputNodes(data) {
+  let inputNodes = /* @__PURE__ */ 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 = false) {
+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);
@@ -376,8 +468,12 @@ 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,
+    imports: [],
     schemas: {},
     data: [],
   };
@@ -425,6 +521,7 @@ function Collapse(nodes, deleteEmpty = false) {
 function Prune(file, deleteEmpty = false) {
   let result = {
     header: file.header,
+    imports: [],
     schemas: file.schemas,
     data: [],
   };
@@ -442,7 +539,99 @@ function Prune(file, deleteEmpty = false) {
   return result;
 }
 
-// compose-flattened.ts
+// ifcx-core/layers/layer-stack.ts
+var IfcxLayerStack = class {
+  // main layer at 0
+  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 = /* @__PURE__ */ new Map();
+    placed.set(activeLayer.header.id, true);
+    let result = await this.SatisfyDependencies(activeLayer, placed, layerSet);
+    if (result instanceof Error) {
+      return result;
+    }
+    return layerSet;
+  }
+};
+
+// viewer/compose-flattened.ts
 function TreeNodeToComposedObject(path, node, schemas) {
   let co = {
     name: path,
@@ -476,105 +665,345 @@ function TreeNodeToComposedObject(path, node, schemas) {
   if (Object.keys(co.attributes).length === 0) delete co.attributes;
   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) => {
+      return { 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());
 }
 
-// render.ts
+// viewer/render.ts
+// import * as THREE from "three";
+// import { OrbitControls } from "three/addons/controls/OrbitControls.js";
+// import { RGBELoader } from "three/addons/loaders/RGBELoader.js";
+import { PCDLoader } from "three/examples/jsm/loaders/PCDLoader.js";
 // var controls;
 // var renderer;
 var scene;
 var camera;
 var datas = [];
 var autoCamera = true;
-// var THREE = window["THREE"];
+var objectMap = {};
+// var domMap = {};
+var primMap = {};
+// var currentPathMapping = null;
+// var rootPrim = null;
+// var selectedObject = null;
+// var selectedDom = null;
+// var raycaster = new THREE.Raycaster();
+// var mouse = new THREE.Vector2();
+var envMap;
 function init() {
   scene = new THREE.Scene();
+  //  const ambient = new THREE.AmbientLight(14544639, 0.4);
+  //  scene.add(ambient);
+  //  const keyLight = new THREE.DirectionalLight(16777215, 1);
+  //  keyLight.position.set(5, -10, 7.5);
+  //  scene.add(keyLight);
+  //  const fillLight = new THREE.DirectionalLight(16777215, 0.5);
+  //  fillLight.position.set(-5, 5, 5);
+  //  scene.add(fillLight);
+  //  const rimLight = new THREE.DirectionalLight(16777215, 0.3);
+  //  rimLight.position.set(0, 8, -10);
+  //  scene.add(rimLight);
   camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 100);
   camera.up.set(0, 0, 1);
   camera.position.set(50, 50, 50);
   camera.lookAt(0, 0, 0);
-  // const nd = document.querySelector(".viewport");
-  // renderer = new THREE.WebGLRenderer({
-  //   alpha: true,
-  //   logarithmicDepthBuffer: true,
+  scene.add(camera);
+  //  const nd = document.querySelector(".viewport");
+  //  renderer = new THREE.WebGLRenderer({
+  //    alpha: true,
+  //    logarithmicDepthBuffer: true,
+  //  });
+  // const pmremGenerator = new THREE.PMREMGenerator(renderer);
+  // pmremGenerator.compileEquirectangularShader();
+  // new RGBELoader().load("images/wildflower_field_1k.hdr", function (texture) {
+  //   envMap = pmremGenerator.fromEquirectangular(texture).texture;
+  //   scene.environment = envMap;
+  //   texture.dispose();
+  //   pmremGenerator.dispose();
   // });
   // renderer.setSize(nd.offsetWidth, nd.offsetHeight);
-  // controls = new THREE.OrbitControls(camera, renderer.domElement);
+  // controls = new OrbitControls(camera, renderer.domElement);
   // controls.enableDamping = true;
   // controls.dampingFactor = 0.25;
   // nd.appendChild(renderer.domElement);
-  scene.add(camera);
+  // renderer.domElement.addEventListener("click", onCanvasClick);
   return scene;
 }
 function HasAttr(node, attrName) {
   if (!node || !node.attributes) return false;
   return !!node.attributes[attrName];
 }
-function FindChildWithAttr(node, attrName) {
-  if (!node || !node.children) return void 0;
-  for (let i = 0; i < node.children.length; i++) {
-    if (HasAttr(node.children[i], attrName)) {
-      return node.children[i];
+// function setHighlight(obj, highlight) {
+//   if (!obj) return;
+//   obj.traverse((o) => {
+//     const mat = o.material;
+//     if (mat && mat.color) {
+//       if (highlight) {
+//         if (!o.userData._origColor) {
+//           o.userData._origColor = mat.color.clone();
+//         }
+//         o.material = mat.clone();
+//         o.material.color.set(16711680);
+//       } else if (o.userData._origColor) {
+//         mat.color.copy(o.userData._origColor);
+//         delete o.userData._origColor;
+//       }
+//     }
+//   });
+// }
+// function selectPath(path) {
+//   if (!path) {
+//     if (selectedObject) setHighlight(selectedObject, false);
+//     if (selectedDom) selectedDom.classList.remove("selected");
+//     selectedObject = null;
+//     selectedDom = null;
+//     return;
+//   }
+//   if (selectedObject) {
+//     setHighlight(selectedObject, false);
+//   }
+//   if (selectedDom) {
+//     selectedDom.classList.remove("selected");
+//   }
+//   selectedObject = objectMap[path] || null;
+//   selectedDom = domMap[path] || null;
+//   if (selectedObject) setHighlight(selectedObject, true);
+//   if (selectedDom) selectedDom.classList.add("selected");
+// }
+// function onCanvasClick(event) {
+//   const rect = renderer.domElement.getBoundingClientRect();
+//   mouse.x = ((event.clientX - rect.left) / rect.width) * 2 - 1;
+//   mouse.y = -((event.clientY - rect.top) / rect.height) * 2 + 1;
+//   raycaster.setFromCamera(mouse, camera);
+//   const intersects = raycaster.intersectObjects(Object.values(objectMap), true);
+//   if (intersects.length > 0) {
+//     let obj = intersects[0].object;
+//     while (obj && !obj.userData.path) obj = obj.parent;
+//     if (obj && obj.userData.path) {
+//       const path = obj.userData.path;
+//       const prim = primMap[path];
+//       if (prim) {
+//         handleClick(prim, currentPathMapping, rootPrim || prim);
+//       }
+//       selectPath(path);
+//     }
+//   } else {
+//     selectPath(null);
+//   }
+// }
+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 !== void 0) {
+        material.metalness = metallicFactor;
+      }
+      let roughnessFactor = pbrMetallicRoughness["roughnessFactor"];
+      if (roughnessFactor !== void 0) {
+        material.roughness = roughnessFactor;
+      }
     }
+    material.envMap = envMap;
+    material.needsUpdate = true;
+    material.envMapRotation = new THREE.Euler(0.5 * Math.PI, 0, 0);
+    return material;
   }
   return void 0;
 }
-function createMaterialFromParent(parent, root) {
-  let reference = parent.attributes["usd::usdshade::materialbindingapi::material::binding"];
+function createMaterialFromParent(path) {
   let material = {
     color: new THREE.Color(0.6, 0.6, 0.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 });
   lineMaterial.color.multiplyScalar(0.8);
   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 = void 0) {
+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"]
@@ -587,7 +1016,7 @@ function traverseTree(node, parent, root, parentNode = void 0) {
       elem.matrix = matrix;
     }
   }
-  (node.children || []).forEach((child) => traverseTree(child, elem || parent, root, node));
+  (node.children || []).forEach((child) => traverseTree([child, ...path], elem || parent, pathMapping));
 }
 // function encodeHtmlEntities(str) {
 //   const div = document.createElement("div");
@@ -598,44 +1027,120 @@ function traverseTree(node, parent, root, parentNode = void 0) {
 //   "usd::usdgeom::mesh::points": "deployed_code",
 //   "usd::usdgeom::basiscurves::points": "line_curve",
 //   "usd::usdshade::material::outputs::surface.connect": "line_style",
+//   "pcd::base64": "grain",
+//   "points::array::positions": "grain",
+//   "points::base64::positions": "grain",
 // };
-// function buildDomTree(prim, node) {
+// function handleClick(prim, pathMapping, root) {
+//   const container = document.querySelector(".attributes .table");
+//   if (container !== null) {
+//     container.innerHTML = "";
+//     const table = document.createElement("table");
+//     table.setAttribute("border", "0");
+//     const entries = [
+//       ["name", prim.name],
+//       ...Object.entries(prim.attributes).filter(([k, _]) => !k.startsWith("__internal_")),
+//     ];
+//     const format = (value) => {
+//       if (Array.isArray(value)) {
+//         let N = document.createElement("span");
+//         N.appendChild(document.createTextNode("("));
+//         let first = true;
+//         for (let n of value.map(format)) {
+//           if (!first) {
+//             N.appendChild(document.createTextNode(","));
+//           }
+//           N.appendChild(n);
+//           first = false;
+//         }
+//         N.appendChild(document.createTextNode(")"));
+//         return N;
+//       } else if (typeof value === "object") {
+//         const ks = Object.keys(value);
+//         if (ks.length == 1 && ks[0] === "ref" && pathMapping[value.ref] && pathMapping[value.ref].length == 1) {
+//           let a = document.createElement("a");
+//           let resolvedRefAsPath = pathMapping[value.ref][0];
+//           a.setAttribute("href", "#");
+//           a.textContent = resolvedRefAsPath;
+//           a.onclick = () => {
+//             let prim2 = null;
+//             const recurse = (n) => {
+//               if (n.name === resolvedRefAsPath) {
+//                 prim2 = n;
+//               } else {
+//                 (n.children || []).forEach(recurse);
+//               }
+//             };
+//             recurse(root);
+//             if (prim2) {
+//               handleClick(prim2, pathMapping, root);
+//             }
+//           };
+//           return a;
+//         } else {
+//           return document.createTextNode(JSON.stringify(value));
+//         }
+//       } else {
+//         return document.createTextNode(value);
+//       }
+//     };
+//     entries.forEach(([key, value]) => {
+//       const tr = document.createElement("tr");
+//       const tdKey = document.createElement("td");
+//       tdKey.textContent = encodeHtmlEntities(key);
+//       const tdValue = document.createElement("td");
+//       tdValue.appendChild(format(value));
+//       tr.appendChild(tdKey);
+//       tr.appendChild(tdValue);
+//       table.appendChild(tr);
+//     });
+//     container.appendChild(table);
+//   }
+// }
+// function buildDomTree(prim, node, pathMapping, root = null) {
 //   const elem = document.createElement("div");
 //   let span;
 //   elem.appendChild(document.createTextNode(prim.name ? prim.name.split("/").reverse()[0] : "root"));
 //   elem.appendChild((span = document.createElement("span")));
 //   Object.entries(icons).forEach(([k, v]) => (span.innerText += (prim.attributes || {})[k] ? v : " "));
 //   span.className = "material-symbols-outlined";
+//   domMap[prim.name] = elem;
+//   elem.dataset.path = prim.name;
 //   elem.onclick = (evt) => {
-//     let rows = [["name", prim.name]]
-//       .concat(Object.entries(prim.attributes))
-//       .map(
-//         ([k, v]) =>
-//           `<tr><td>${encodeHtmlEntities(k)}</td><td>${encodeHtmlEntities(typeof v === "object" ? JSON.stringify(v) : v)}</td>`
-//       )
-//       .join("");
-//     document.querySelector(".attributes .table").innerHTML = `<table border="0">${rows}</table>`;
+//     handleClick(prim, pathMapping, root || prim);
+//     selectPath(prim.name);
 //     evt.stopPropagation();
 //   };
 //   node.appendChild(elem);
-//   (prim.children || []).forEach((p) => buildDomTree(p, elem));
+//   (prim.children || []).forEach((p) => buildDomTree(p, elem, pathMapping, root || prim));
 // }
-function composeAndRender() {
+async function composeAndRender() {
   if (scene) {
     scene.children = [];
   }
+  objectMap = {};
+  // domMap = {};
+  primMap = {};
+  // currentPathMapping = null;
+  // rootPrim = null;
   // document.querySelector(".tree").innerHTML = "";
   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);
+  // currentPathMapping = pathMapping;
+  // rootPrim = tree;
   if (autoCamera) {
     const boundingBox = new THREE.Box3();
     boundingBox.setFromObject(scene);
@@ -650,7 +1155,7 @@ function composeAndRender() {
       autoCamera = false;
     }
   }
-  // buildDomTree(tree, document.querySelector(".tree"));
+  // buildDomTree(tree, document.querySelector(".tree"), pathMapping);
   // animate();
 }
 // function createLayerDom() {
@@ -682,10 +1187,10 @@ function composeAndRender() {
 //     document.querySelector(".layers div").appendChild(elem);
 //   });
 // }
-// function addModel(name, m) {
+// async function addModel(name, m) {
 //   datas.push([name, m]);
 //   createLayerDom();
-//   composeAndRender();
+//   await composeAndRender();
 // }
 // function animate() {
 //   requestAnimationFrame(animate);
@@ -694,9 +1199,9 @@ function composeAndRender() {
 // }
 // export { composeAndRender, addModel as default };
 
-export function parse(m, name) {
+export async function parse(m, name) {
   datas.push([name, m]);
-  composeAndRender();
+  await composeAndRender();
   return scene;
 }
 export function clear() {