text: import {Plugin} from "../../viewer/Plugin.js";
  import {SectionPlane} from "../../viewer/scene/sectionPlane/SectionPlane.js";
  import {math} from "../../viewer/scene/math/math.js";
  
  const tempVec3 = math.vec3();
  
  /**
   * {@link Viewer} plugin that saves and loads BCF viewpoints as JSON objects.
   *
   * BCF is a format for managing issues on a BIM project. This plugin's viewpoints conform to
   * the <a href="https://github.com/buildingSMART/BCF-API">BCF Version 2.1</a> specification.
   *
   * ## Saving a BCF Viewpoint
   *
   * In the example below we'll create a {@link Viewer}, load an ````.XKT```` model into it using an {@link XKTLoaderPlugin},
   * slice the model in half using a {@link SectionPlanesPlugin}, then use a {@link BCFViewpointsPlugin#getViewpoint}
   * to save a viewpoint to JSON, which we'll log to the JavaScript developer console.
   *
   * * [[Run this example](http://xeokit.github.io/xeokit-sdk/examples/#BCF_SaveViewpoint)]
   *
   * ````javascript
   * import {Viewer, XKTLoaderPlugin, SectionPlanesPlugin, BCFViewpointsPlugin} from "xeokit-sdk.es.js";
   *
   * // Create a Viewer
   * const viewer = new Viewer({
   *      canvasId: "myCanvas",
   *      transparent: true
   * });
   *
   * // Add a XKTLoaderPlugin
   * const xktLoader = new XKTLoaderPlugin(viewer);
   *
   * // Add a SectionPlanesPlugin
   * const sectionPlanes = new SectionPlanesPlugin(viewer);
   *
   * // Add a BCFViewpointsPlugin
   * const bcfViewpoints = new BCFViewpointsPlugin(viewer);
   *
   * // Load an .XKT model
   * const modelNode = xktLoader.load({
   *      id: "myModel",
   *      src: "./models/xkt/Schependomlaan.xkt",
   *      edges: true // Emphasise edges
   * });
   *
   * // Slice it in half
   * sectionPlanes.createSectionPlane({
   *      id: "myClip",
   *      pos: [0, 0, 0],
   *      dir: [0.5, 0.0, 0.5]
   * });
   *
   * // When model is loaded, set camera, select some objects and capture a BCF viewpoint to the console
   * modelNode.on("loaded", () => {
   *
   *      const scene = viewer.scene;
   *      const camera = scene.camera;
   *
   *      camera.eye = [-2.37, 18.97, -26.12];
   *      camera.look = [10.97, 5.82, -11.22];
   *      camera.up = [0.36, 0.83, 0.40];
   *
   *      scene.setObjectsSelected([
   *          "3b2U496P5Ebhz5FROhTwFH",
   *          "2MGtJUm9nD$Re1_MDIv0g2",
   *          "3IbuwYOm5EV9Q6cXmwVWqd",
   *          "3lhisrBxL8xgLCRdxNG$2v",
   *          "1uDn0xT8LBkP15zQc9MVDW"
   *      ], true);
   *
   *      const viewpoint = bcfViewpoints.getViewpoint();
   *      const viewpointStr = JSON.stringify(viewpoint, null, 4);
   *
   *      console.log(viewpointStr);
   * });
   * ````
   *
   * ## Saving View Setup Hints
   *
   * BCFViewpointsPlugin can optionally save hints in the viewpoint, which indicate how to set up the view when
   * loading it again.
   *
   * Here's the {@link BCFViewpointsPlugin#getViewpoint} call again, this time saving some hints:
   *
   * ````javascript
   * const viewpoint = bcfViewpoints.getViewpoint({ // Options
   *     spacesVisible: true, // Force IfcSpace types visible in the viewpoint (default is false)
   *     spaceBoundariesVisible: false, // Show IfcSpace boundaries in the viewpoint (default is false)
   *     openingsVisible: true // Force IfcOpening types visible in the viewpoint (default is false)
   * });
   * ````
   *
   * ## Loading a BCF Viewpoint
   *
   * Assuming that we have our BCF viewpoint in a JSON object, let's now restore it with {@link BCFViewpointsPlugin#setViewpoint}:
   *
   * ````javascript
   * bcfViewpoints.setViewpoint(viewpoint);
   * ````
   *
   * ## Handling BCF Incompatibility with xeokit's Camera
   *
   * xeokit's {@link Camera#look} is the current 3D *point-of-interest* (POI).
   *
   * A BCF viewpoint, however, has a direction vector instead of a POI, and so {@link BCFViewpointsPlugin#getViewpoint} saves
   * xeokit's POI as a normalized vector from {@link Camera#eye} to {@link Camera#look}, which unfortunately loses
   * that positional information. Loading the viewpoint with {@link BCFViewpointsPlugin#setViewpoint} will restore {@link Camera#look} to
   * the viewpoint's camera position, offset by the normalized vector.
   *
   * As shown below, providing a ````rayCast```` option to ````setViewpoint```` will set {@link Camera#look} to the closest
   * surface intersection on the direction vector. Internally, ````setViewpoint```` supports this option by firing a ray
   * along the vector, and if that hits an {@link Entity}, sets {@link Camera#look} to ray's intersection point with the
   * Entity's surface.
   *
   * ````javascript
   * bcfViewpoints.setViewpoint(viewpoint, {
   *      rayCast: true // <<--------------- Attempt to set Camera#look to surface intersection point (default)
   * });
   * ````
   *
   * ## Dealing With Loaded Models That Are Not in the Viewpoint
   *
   * If, for example, we load model "duplex", hide some objects, then save a BCF viewpoint with
   * ````BCFViewpointsPlugin#getViewpoint````, then load another model, "schependomlaan", then load the viewpoint again
   * with ````BCFViewpointsPlugin#setViewpoint````, then sometimes all of the objects in model "schependomlaan" become
   * visible, along with the visible objects in the viewpoint, which belong to model "duplex".
   *
   * The reason is that, when saving a BCF viewpoint, BCF logic works like the following pseudo code:
   *
   * ````
   * If numVisibleObjects < numInvisibleObjects
   *      save IDs of visible objects in BCF
   *      exceptions = "visible objects"
   * else
   *      save IDS of invisible objects in BCF
   *      exceptions = "invisible objects"
   * ````
   *
   * When loading the viewpoint again:
   *
   * ````
   * If exceptions = "visible objects"
   *      hide all objects
   *      show visible objects in BCF
   * else
   *      show all objects
   *      hide invisible objects in BCF
   * ````
   *
   * When the exception is "visible objects", loading the viewpoint shows all the objects in the first, which includes
   * objects in "schependomlaan", which can be confusing, because those were not even loaded when we first
   * saved the viewpoint..
   *
   * To solve this, we can supply a ````defaultInvisible```` option to {@link BCFViewpointsPlugin#getViewpoint}, which
   * will force the plugin to save the IDs of all visible objects while making invisible objects the exception.
   *
   * That way, when we load the viewpoint again, after loading model "schependomlaan", the plugin will hide all objects
   * in the scene first (which will include objects belonging to model "schependomlaan"), then make the objects in the
   * viewpoint visible (which will only be those of object "duplex").
   *
   * ````javascript
   * const viewpoint = bcfViewpoints.getViewpoint({ // Options
   *     //..
   *     defaultInvisible: true
   * });
   * ````
   *
   * [[Run an example](http://xeokit.github.io/xeokit-sdk/examples/#BCF_LoadViewpoint_defaultInvisible)]
   *
   * ## Behaviour with XKTLoaderPlugin globalizeObjectIds
   *
   * Whenever we use {@link XKTLoaderPlugin} to load duplicate copies of the same model, after configuring
   * {@link XKTLoaderPlugin#globalizeObjectIds} ````true```` to avoid ````Entity```` ID clashes, this has consequences
   * for BCF viewpoints created by {@link BCFViewpointsPlugin#getViewpoint}.
   *
   * When no duplicate copies of a model are loaded like this, viewpoints created by {@link BCFViewpointsPlugin#getViewpoint} will
   * continue to load as usual in other BIM viewers. Conversely, a viewpoint created for a single model in other BIM viewers
   * will continue to load as usual with ````BCFViewpointsPlugin````.
   *
   * When duplicate copies of a model are loaded, however, viewpoints created by {@link BCFViewpointsPlugin#getViewpoint}
   * will contain certain changes that will affect the viewpoint's portability, however. Such viewpoints will
   * use ````authoring_tool_id```` fields to save the globalized ````Entity#id```` values, which enables the viewpoints to
   * capture the states of the individual ````Entitys```` that represent the duplicate IFC elements. Take a look at the
   * following two examples to learn more.
   *
   * * [Example: Saving a BCF viewpoint containing duplicate models](https://xeokit.github.io/xeokit-sdk/examples/#BCF_SaveViewpoint_MultipleModels)
   * * [Example: Loading a BCF viewpoint containing duplicate models](https://xeokit.github.io/xeokit-sdk/examples/#BCF_LoadViewpoint_MultipleModels)
   *
   * **Caveat:** when loading a BCF viewpoint, we always assume that we have loaded in our target BIM viewer the same models that were
   * loaded in the viewpoint's original authoring application when the viewpoint was created.  In the case of multi-model
   * viewpoints, the target BIM viewer, whether it be xeokit or another BIM viewer, will need to first have those exact
   * models loaded, with their objects having globalized IDs, following the same prefixing scheme we're using in
   * xeokit. Then, the viewpoint's ````authoring_tool_id```` fields will be able to resolve to their objects within the
   * target viewer.
  *
   * @class BCFViewpointsPlugin
   */
  class BCFViewpointsPlugin extends Plugin {
  
      /**
       * @constructor
       * @param {Viewer} viewer The Viewer.
       * @param {Object} cfg  Plugin configuration.
       * @param {String} [cfg.id="BCFViewpoints"] Optional ID for this plugin, so that we can find it within {@link Viewer#plugins}.
       * @param {String} [cfg.originatingSystem] Identifies the originating system for BCF records.
       * @param {String} [cfg.authoringTool] Identifies the authoring tool for BCF records.
       */
      constructor(viewer, cfg = {}) {
  
          super("BCFViewpoints", viewer, cfg);
  
          /**
           * Identifies the originating system to include in BCF viewpoints saved by this plugin.
           * @property originatingSystem
           * @type {string}
           */
          this.originatingSystem = cfg.originatingSystem || "xeokit.io";
  
          /**
           * Identifies the authoring tool to include in BCF viewpoints saved by this plugin.
           * @property authoringTool
           * @type {string}
           */
          this.authoringTool = cfg.authoringTool || "xeokit.io";
      }
  
      /**
       * Saves viewer state to a BCF viewpoint.
       *
       * Note that xeokit's {@link Camera#look} is the **point-of-interest**, whereas the BCF ````camera_direction```` is a
       * direction vector. Therefore, we save ````camera_direction```` as the vector from {@link Camera#eye} to {@link Camera#look}.
       *
       * @param {*} [options] Options for getting the viewpoint.
       * @param {Boolean} [options.spacesVisible=false] Indicates whether ````IfcSpace```` types should be forced visible in the viewpoint.
       * @param {Boolean} [options.openingsVisible=false] Indicates whether ````IfcOpening```` types should be forced visible in the viewpoint.
       * @param {Boolean} [options.spaceBoundariesVisible=false] Indicates whether the boundaries of ````IfcSpace```` types should be visible in the viewpoint.
       * @param {Boolean} [options.snapshot=true] Indicates whether the snapshot should be included in the viewpoint.
       * @param {Boolean} [options.defaultInvisible=false] When ````true````, will save the default visibility of all objects
       * as ````false````. This means that when we load the viewpoint again, and there are additional models loaded that
       * were not saved in the viewpoint, those models will be hidden when we load the viewpoint, and that only the
       * objects in the viewpoint will be visible.
       * @param {Boolean} [options.reverseClippingPlanes=false] When ````true````, clipping planes are reversed (https://github.com/buildingSMART/BCF-XML/issues/193)
       * @returns {*} BCF JSON viewpoint object
       * @example
       *
       * const viewer = new Viewer();
       *
       * const bcfPlugin = new BCFPlugin(viewer, {
       *     //...
       * });
       *
       * const viewpoint = bcfPlugin.getViewpoint({ // Options - see constructor
       *     spacesVisible: false,          // Default
       *     spaceBoundariesVisible: false, // Default
       *     openingsVisible: false         // Default
       * });
       *
       * // viewpoint will resemble the following:
       *
       * {
       *     perspective_camera: {
       *         camera_view_point: {
       *             x: 0.0,
       *             y: 0.0,
       *             z: 0.0
       *         },
       *         camera_direction: {
       *             x: 1.0,
       *             y: 1.0,
       *             z: 2.0
       *         },
       *         camera_up_vector: {
       *             x: 0.0,
       *             y: 0.0,
       *             z: 1.0
       *         },
       *         field_of_view: 90.0
       *     },
       *     lines: [],
       *     clipping_planes: [{
       *         location: {
       *             x: 0.5,
       *             y: 0.5,
       *             z: 0.5
       *         },
       *         direction: {
       *             x: 1.0,
       *             y: 0.0,
       *             z: 0.0
       *         }
       *     }],
       *     bitmaps: [],
       *     snapshot: {
       *         snapshot_type: png,
       *         snapshot_data: "data:image/png;base64,......"
       *     },
       *     components: {
       *         visibility: {
       *             default_visibility: false,
       *             exceptions: [{
       *                 ifc_guid: 4$cshxZO9AJBebsni$z9Yk,
       *                 originating_system: xeokit.io,
       *                 authoring_tool_id: xeokit/v1.0
       *             }]
       *        },
       *         selection: [{
       *            ifc_guid: "4$cshxZO9AJBebsni$z9Yk",
       *         }]
       *     }
       * }
       */
      getViewpoint(options = {}) {
          const scene = this.viewer.scene;
          const camera = scene.camera;
          const realWorldOffset = scene.realWorldOffset;
          const reverseClippingPlanes = (options.reverseClippingPlanes === true);
          let bcfViewpoint = {};
  
          // Camera
          let lookDirection = math.normalizeVec3(math.subVec3(camera.look, camera.eye, math.vec3()));
          let eye = camera.eye;
          let up = camera.up;
  
          if (camera.yUp) {
              // BCF is Z up
              lookDirection = YToZ(lookDirection);
              eye = YToZ(eye);
              up = YToZ(up);
          }
  
          const camera_view_point = xyzArrayToObject(math.addVec3(eye, realWorldOffset));
  
          if (camera.projection === "ortho") {
              bcfViewpoint.orthogonal_camera = {
                  camera_view_point: camera_view_point,
                  camera_direction: xyzArrayToObject(lookDirection),
                  camera_up_vector: xyzArrayToObject(up),
                  view_to_world_scale: camera.ortho.scale,
              };
          } else {
              bcfViewpoint.perspective_camera = {
                  camera_view_point: camera_view_point,
                  camera_direction: xyzArrayToObject(lookDirection),
                  camera_up_vector: xyzArrayToObject(up),
                  field_of_view: camera.perspective.fov,
              };
          }
  
          // Clipping planes
  
          const sectionPlanes = scene.sectionPlanes;
          for (let id in sectionPlanes) {
              if (sectionPlanes.hasOwnProperty(id)) {
                  let sectionPlane = sectionPlanes[id];
  
                  let location = sectionPlane.pos;
  
                  let direction;
                  if (reverseClippingPlanes) {
                      direction = math.negateVec3(sectionPlane.dir, math.vec3());
                  } else {
                      direction = sectionPlane.dir;
                  }
  
                  if (camera.yUp) {
                      // BCF is Z up
                      location = YToZ(location);
                      direction = YToZ(direction);
                  }
                  math.addVec3(location, realWorldOffset);
  
                  location = xyzArrayToObject(location);
                  direction = xyzArrayToObject(direction);
                  if (!bcfViewpoint.clipping_planes) {
                      bcfViewpoint.clipping_planes = [];
                  }
                  bcfViewpoint.clipping_planes.push({location, direction});
              }
          }
  
          // Entity states
  
          bcfViewpoint.components = {
              visibility: {
                  view_setup_hints: {
                      spaces_visible: !!options.spacesVisible,
                      space_boundaries_visible: !!options.spaceBoundariesVisible,
                      openings_visible: !!options.openingsVisible
                  }
              }
          };
  
          const opacityObjectIds = new Set(scene.opacityObjectIds);
          const xrayedObjectIds = new Set(scene.xrayedObjectIds);
          const colorizedObjectIds = new Set(scene.colorizedObjectIds);
  
          const originalSystemColoringMap = {};
  
          const coloringMap = Object.values(scene.objects)
              .filter(entity => opacityObjectIds.has(entity.id) || colorizedObjectIds.has(entity.id) || xrayedObjectIds.has(entity.id))
              .reduce((coloringMap, entity) => {
  
                  let color = colorizeToRGB(entity.colorize);
                  let alpha;
  
                  if (entity.xrayed) {
                      if (scene.xrayMaterial.fillAlpha === 0.0 && scene.xrayMaterial.edgeAlpha !== 0.0) {
                          // BCF can't deal with edges. If xRay is implemented only with edges, set an arbitrary opacity
                          alpha = 0.1;
                      } else {
                          alpha = scene.xrayMaterial.fillAlpha;
                      }
                      alpha = Math.round(alpha * 255).toString(16).padStart(2, "0");
                      color = alpha + color;
                  } else if (opacityObjectIds.has(entity.id)) {
                      alpha = Math.round(entity.opacity * 255).toString(16).padStart(2, "0");
                      color = alpha + color;
                  }
  
                  if (!coloringMap[color]) {
                      coloringMap[color] = [];
                  }
  
                  const objectId = entity.id;
                  const originalSystemId = entity.originalSystemId;
                  const component = {
                      ifc_guid: originalSystemId,
                      originating_system: this.originatingSystem
                  };
                  if (originalSystemId !== objectId) {
                      component.authoring_tool_id = objectId;
                  }
  
                  coloringMap[color].push(component);
  
                  return coloringMap;
  
              }, {});
  
          const coloringArray = Object.entries(coloringMap).map(([color, components]) => {
              return {color, components};
          });
  
          bcfViewpoint.components.coloring = coloringArray;
  
          const objectIds = scene.objectIds;
          const visibleObjects = scene.visibleObjects;
          const visibleObjectIds = scene.visibleObjectIds;
          const invisibleObjectIds = objectIds.filter(id => !visibleObjects[id]);
          const selectedObjectIds = scene.selectedObjectIds;
  
          if (options.defaultInvisible || visibleObjectIds.length < invisibleObjectIds.length) {
              bcfViewpoint.components.visibility.exceptions = this._createBCFComponents(visibleObjectIds);
              bcfViewpoint.components.visibility.default_visibility = false;
          } else {
              bcfViewpoint.components.visibility.exceptions = this._createBCFComponents(invisibleObjectIds);
              bcfViewpoint.components.visibility.default_visibility = true;
          }
  
          bcfViewpoint.components.selection = this._createBCFComponents(selectedObjectIds);
  
          if (options.snapshot !== false) {
              bcfViewpoint.snapshot = {
                  snapshot_type: "png",
                  snapshot_data: this.viewer.getSnapshot({format: "png"})
              };
          }
  
          return bcfViewpoint;
      }
  
      _createBCFComponents(objectIds) {
          const scene = this.viewer.scene;
          const components = [];
          for (let i = 0, len = objectIds.length; i < len; i++) {
              const objectId = objectIds[i];
              const entity = scene.objects[objectId];
              if (entity) {
                  const component = {
                      ifc_guid: entity.originalSystemId,
                      originating_system: this.originatingSystem
                  };
                  if (entity.originalSystemId !== objectId) {
                      component.authoring_tool_id = objectId;
                  }
                  components.push(component);
              }
          }
          return components;
      }
  
      /**
       * Sets viewer state to the given BCF viewpoint.
       *
       * Note that xeokit's {@link Camera#look} is the **point-of-interest**, whereas the BCF ````camera_direction```` is a
       * direction vector. Therefore, when loading a BCF viewpoint, we set {@link Camera#look} to the absolute position
       * obtained by offsetting the BCF ````camera_view_point````  along ````camera_direction````.
       *
       * When loading a viewpoint, we also have the option to find {@link Camera#look} as the closest point of intersection
       * (on the surface of any visible and pickable {@link Entity}) with a 3D ray fired from ````camera_view_point```` in
       * the direction of ````camera_direction````.
       *
       * @param {*} bcfViewpoint  BCF JSON viewpoint object,
       * shows default visible entities and restores camera to initial default position.
       * @param {*} [options] Options for setting the viewpoint.
       * @param {Boolean} [options.rayCast=true] When ````true```` (default), will attempt to set {@link Camera#look} to the closest
       * point of surface intersection with a ray fired from the BCF ````camera_view_point```` in the direction of ````camera_direction````.
       * @param {Boolean} [options.immediate=true] When ````true```` (default), immediately set camera position.
       * @param {Boolean} [options.duration] Flight duration in seconds.  Overrides {@link CameraFlightAnimation#duration}. Only applies when ````immediate```` is ````false````.
       * @param {Boolean} [options.reset=true] When ````true```` (default), set {@link Entity#xrayed} and {@link Entity#highlighted} ````false```` on all scene objects.
       * @param {Boolean} [options.reverseClippingPlanes=false] When ````true````, clipping planes are reversed (https://github.com/buildingSMART/BCF-XML/issues/193)
       * @param {Boolean} [options.updateCompositeObjects=false] When ````true````, then when visibility and selection updates refer to composite objects (eg. an IfcBuildingStorey),
       * then this method will apply the updates to objects within those composites.
       */
      setViewpoint(bcfViewpoint, options = {}) {
          if (!bcfViewpoint) {
              return;
          }
  
          const viewer = this.viewer;
          const scene = viewer.scene;
          const camera = scene.camera;
          const rayCast = (options.rayCast !== false);
          const immediate = (options.immediate !== false);
          const reset = (options.reset !== false);
          const realWorldOffset = scene.realWorldOffset;
          const reverseClippingPlanes = (options.reverseClippingPlanes === true);
  
          scene.clearSectionPlanes();
  
          if (bcfViewpoint.clipping_planes) {
              bcfViewpoint.clipping_planes.forEach(function (e) {
                  let pos = xyzObjectToArray(e.location, tempVec3);
                  let dir = xyzObjectToArray(e.direction, tempVec3);
  
                  if (reverseClippingPlanes) {
                      math.negateVec3(dir);
                  }
                  math.subVec3(pos, realWorldOffset);
  
                  if (camera.yUp) {
                      pos = ZToY(pos);
                      dir = ZToY(dir);
                  }
                  new SectionPlane(scene, {pos, dir});
              });
          }
  
          if (reset) {
              scene.setObjectsXRayed(scene.xrayedObjectIds, false);
              scene.setObjectsHighlighted(scene.highlightedObjectIds, false);
              scene.setObjectsSelected(scene.selectedObjectIds, false);
          }
  
          if (bcfViewpoint.components) {
  
              if (bcfViewpoint.components.visibility) {
  
                  if (!bcfViewpoint.components.visibility.default_visibility) {
                      scene.setObjectsVisible(scene.objectIds, false);
                      if (bcfViewpoint.components.visibility.exceptions) {
                          bcfViewpoint.components.visibility.exceptions.forEach((component) => this._withBCFComponent(options, component, entity => entity.visible = true));
                      }
                  } else {
                      scene.setObjectsVisible(scene.objectIds, true);
                      if (bcfViewpoint.components.visibility.exceptions) {
                          bcfViewpoint.components.visibility.exceptions.forEach((component) => this._withBCFComponent(options, component, entity => entity.visible = false));
                      }
                  }
  
                  const view_setup_hints = bcfViewpoint.components.visibility.view_setup_hints;
                  if (view_setup_hints) {
                      if (view_setup_hints.spaces_visible === false) {
                          scene.setObjectsVisible(viewer.metaScene.getObjectIDsByType("IfcSpace"), false);
                      }
                      if (view_setup_hints.openings_visible === false) {
                          scene.setObjectsVisible(viewer.metaScene.getObjectIDsByType("IfcOpening"), false);
                      }
                      if (view_setup_hints.space_boundaries_visible !== undefined) {
                          // TODO: Ability to show boundaries
                      }
                  }
              }
  
              if (bcfViewpoint.components.selection) {
                  scene.setObjectsSelected(scene.selectedObjectIds, false);
                  bcfViewpoint.components.selection.forEach(component => this._withBCFComponent(options, component, entity => entity.selected = true));
  
              }
  
              if (bcfViewpoint.components.coloring) {
                  bcfViewpoint.components.coloring.forEach(coloring => {
  
                      let color = coloring.color;
                      let alpha = 0;
                      let alphaDefined = false;
  
                      if (color.length === 8) {
                          alpha = parseInt(color.substring(0, 2), 16) / 256;
                          if (alpha <= 1.0 && alpha >= 0.95) {
                              alpha = 1.0;
                          }
                          color = color.substring(2);
                          alphaDefined = true;
                      }
  
                      const colorize = [
                          parseInt(color.substring(0, 2), 16) / 256,
                          parseInt(color.substring(2, 4), 16) / 256,
                          parseInt(color.substring(4, 6), 16) / 256
                      ];
  
                      coloring.components.map(component =>
                          this._withBCFComponent(options, component, entity => {
                              entity.colorize = colorize;
                              if (alphaDefined) {
                                  entity.opacity = alpha;
                              }
                          }));
                  });
              }
          }
  
          if (bcfViewpoint.perspective_camera || bcfViewpoint.orthogonal_camera) {
              let eye;
              let look;
              let up;
              let projection;
  
              if (bcfViewpoint.perspective_camera) {
                  eye = xyzObjectToArray(bcfViewpoint.perspective_camera.camera_view_point, tempVec3);
                  look = xyzObjectToArray(bcfViewpoint.perspective_camera.camera_direction, tempVec3);
                  up = xyzObjectToArray(bcfViewpoint.perspective_camera.camera_up_vector, tempVec3);
  
                  camera.perspective.fov = bcfViewpoint.perspective_camera.field_of_view;
  
                  projection = "perspective";
              } else {
                  eye = xyzObjectToArray(bcfViewpoint.orthogonal_camera.camera_view_point, tempVec3);
                  look = xyzObjectToArray(bcfViewpoint.orthogonal_camera.camera_direction, tempVec3);
                  up = xyzObjectToArray(bcfViewpoint.orthogonal_camera.camera_up_vector, tempVec3);
  
                  camera.ortho.scale = bcfViewpoint.orthogonal_camera.view_to_world_scale;
  
                  projection = "ortho";
              }
  
              math.subVec3(eye, realWorldOffset);
  
              if (camera.yUp) {
                  eye = ZToY(eye);
                  look = ZToY(look);
                  up = ZToY(up);
              }
  
              if (rayCast) {
                  const hit = scene.pick({
                      pickSurface: true,  // <<------ This causes picking to find the intersection point on the entity
                      origin: eye,
                      direction: look
                  });
                  look = (hit ? hit.worldPos : math.addVec3(eye, look, tempVec3));
              } else {
                  look = math.addVec3(eye, look, tempVec3);
              }
  
              if (immediate) {
                  camera.eye = eye;
                  camera.look = look;
                  camera.up = up;
                  camera.projection = projection;
              } else {
                  viewer.cameraFlight.flyTo({eye, look, up, duration: options.duration, projection});
              }
          }
      }
  
      _withBCFComponent(options, component, callback) {
  
          const viewer = this.viewer;
          const scene = viewer.scene;
  
          if (component.authoring_tool_id && component.originating_system === this.originatingSystem) {
  
              const id = component.authoring_tool_id;
              const entity = scene.objects[id];
  
              if (entity) {
                  callback(entity);
                  return
              }
  
              if (options.updateCompositeObjects) {
                  const metaObject = viewer.metaScene.metaObjects[id];
                  if (metaObject) {
                      scene.withObjects(viewer.metaScene.getObjectIDsInSubtree(id), callback);
                      return;
                  }
              }
          }
  
          if (component.ifc_guid) {
  
              const originalSystemId = component.ifc_guid;
              const entity = scene.objects[originalSystemId];
  
              if (entity) {
                  callback(entity);
                  return;
              }
  
              if (options.updateCompositeObjects) {
                  const metaObject = viewer.metaScene.metaObjects[originalSystemId];
                  if (metaObject) {
                      scene.withObjects(viewer.metaScene.getObjectIDsInSubtree(originalSystemId), callback);
                      return;
                  }
              }
  
              Object.keys(scene.models).forEach((modelId) => {
  
                  const id = math.globalizeObjectId(modelId, originalSystemId);
                  const entity = scene.objects[id];
  
                  if (entity) {
                      callback(entity);
                      return;
                  }
  
                  if (options.updateCompositeObjects) {
                      const metaObject = viewer.metaScene.metaObjects[id];
                      if (metaObject) {
                          scene.withObjects(viewer.metaScene.getObjectIDsInSubtree(id), callback);
                          return;
                      }
                  }
              });
          }
      }
  
      /**
       * Destroys this BCFViewpointsPlugin.
       */
      destroy() {
          super.destroy();
      }
  }
  
  function xyzArrayToObject(arr) {
      return {"x": arr[0], "y": arr[1], "z": arr[2]};
  }
  
  function xyzObjectToArray(xyz, arry) {
      arry = new Float64Array(3);
      arry[0] = xyz.x;
      arry[1] = xyz.y;
      arry[2] = xyz.z;
      return arry;
  }
  
  function YToZ(vec) {
      return new Float64Array([vec[0], -vec[2], vec[1]]);
  }
  
  function ZToY(vec) {
      return new Float64Array([vec[0], vec[2], -vec[1]]);
  }
  
  function colorizeToRGB(color) {
      let rgb = "";
      rgb += Math.round(color[0] * 255).toString(16).padStart(2, "0");
      rgb += Math.round(color[1] * 255).toString(16).padStart(2, "0");
      rgb += Math.round(color[2] * 255).toString(16).padStart(2, "0");
      return rgb;
  }
  
  export {BCFViewpointsPlugin};
  