@xeokit/xeokit-sdk 2.3.0-beta-19 → 2.3.0-beta-22

package/dist/xeokit-sdk.cjs.js

@@ -104,7 +104,7 @@ class Item {
  * * Dynamically enable or disable items
  * * Dynamically show or hide items
  * * Supports cascading sub-menus
- * * Configure custom style with custom CSS (see examples above)
+ * * Configure custom style with CSS (see examples above)
  *
  * ## Usage
  *
@@ -1279,7 +1279,7 @@ const math = {
      * Returns true if the two 3-element vectors are the same.
      * @param v1
      * @param v2
-     * @returns {boolean}
+     * @returns {Boolean}
      */
     compareVec3(v1, v2) {
         return (v1[0] === v2[0] && v1[1] === v2[1] && v1[2] === v2[2]);
@@ -3435,7 +3435,7 @@ const math = {
      * Returns true if the two 4x4 matrices are the same.
      * @param m1
      * @param m2
-     * @returns {boolean}
+     * @returns {Boolean}
      */
     compareMat4(m1, m2) {
         return m1[0] === m2[0] &&
@@ -4342,7 +4342,7 @@ const math = {
     /** Returns true if the first AABB contains the second AABB.
      * @param aabb1
      * @param aabb2
-     * @returns {boolean}
+     * @returns {Boolean}
      */
     containsAABB3: function (aabb1, aabb2) {
         const result = (
@@ -6738,7 +6738,7 @@ function isArray(value) {
 /**
  Tests if the given value is a string
  @param value
- @returns {boolean}
+ @returns {Boolean}
  @private
  */
 function isString(value) {
@@ -6748,7 +6748,7 @@ function isString(value) {
 /**
  Tests if the given value is a number
  @param value
- @returns {boolean}
+ @returns {Boolean}
  @private
  */
 function isNumeric(value) {
@@ -6758,7 +6758,7 @@ function isNumeric(value) {
 /**
  Tests if the given value is an ID
  @param value
- @returns {boolean}
+ @returns {Boolean}
  @private
  */
 function isID(value) {
@@ -6769,7 +6769,7 @@ function isID(value) {
  Tests if the given components are the same, where the components can be either IDs or instances.
  @param c1
  @param c2
- @returns {boolean}
+ @returns {Boolean}
  @private
  */
 function isSameComponent(c1, c2) {
@@ -6784,7 +6784,7 @@ function isSameComponent(c1, c2) {
 /**
  Tests if the given value is a function
  @param value
- @returns {boolean}
+ @returns {Boolean}
  @private
  */
 function isFunction$1(value) {
@@ -6794,7 +6794,7 @@ function isFunction$1(value) {
 /**
  Tests if the given value is a JavaScript JSON object, eg, ````{ foo: "bar" }````.
  @param value
- @returns {boolean}
+ @returns {Boolean}
  @private
  */
 function isObject$1(value) {
@@ -6852,7 +6852,7 @@ function applyIf(o, o2) {
 /**
  Returns true if the given map is empty.
  @param obj
- @returns {boolean}
+ @returns {Boolean}
  @private
  */
 function isEmptyObject$1(obj) {
@@ -9868,10 +9868,23 @@ class AngleMeasurement extends Component {
         return this._angle;
     }
 
+    /**
+     * Gets the color of the angle measurement.
+     *
+     * The color is an HTML string representation, eg. "#00BBFF" and "blue".
+     *
+     * @type {String}
+     */
     get color() {
         return this._color;
     }
 
+    /** Sets the color of the angle measurement.
+     *
+     * The color is given as an HTML string representation, eg. "#00BBFF" and "blue".
+     *
+     * @type {String}
+     */
     set color(value) {
         this._originDot.setFillColor(value);
         this._cornerDot.setFillColor(value);
@@ -9886,7 +9899,7 @@ class AngleMeasurement extends Component {
     /**
      * Sets whether this AngleMeasurement is visible or not.
      *
-     * @type Boolean
+     * @type {Boolean}
      */
     set visible(value) {
         value = value !== false;
@@ -9902,7 +9915,7 @@ class AngleMeasurement extends Component {
     /**
      * Gets whether this AngleMeasurement is visible or not.
      *
-     * @type Boolean
+     * @type {Boolean}
      */
     get visible() {
         return this._visible;
@@ -10098,7 +10111,7 @@ class AngleMeasurementsControl extends Component {
 
     /** Gets if this AngleMeasurementsControl is currently active, where it is responding to input.
      *
-     * @returns {boolean}
+     * @returns {Boolean}
      */
     get active() {
         return this._active;
@@ -13746,7 +13759,7 @@ class OcclusionTester {
     /**
      * Returns true if an occlusion test is needed.
      *
-     * @returns {boolean}
+     * @returns {Boolean}
      */
     get needOcclusionTest() {
         return this._occlusionTestListDirty;
@@ -15499,7 +15512,7 @@ const Renderer = function (scene, options) {
 
     /**
      * Returns true if the next call to render() will draw something
-     * @returns {boolean}
+     * @returns {Boolean}
      */
     this.needsRender = function () {
         return (imageDirty || drawableListDirty || stateSortDirty);
@@ -19882,7 +19895,7 @@ class Camera extends Component {
 
     /**
      * Gets if the World-space X-axis is "up".
-     * @returns {boolean}
+     * @returns {Boolean}
      */
     get xUp() {
         return this._worldUp[0] > this._worldUp[1] && this._worldUp[0] > this._worldUp[2];
@@ -19890,7 +19903,7 @@ class Camera extends Component {
 
     /**
      * Gets if the World-space Y-axis is "up".
-     * @returns {boolean}
+     * @returns {Boolean}
      */
     get yUp() {
         return this._worldUp[1] > this._worldUp[0] && this._worldUp[1] > this._worldUp[2];
@@ -19898,7 +19911,7 @@ class Camera extends Component {
 
     /**
      * Gets if the World-space Z-axis is "up".
-     * @returns {boolean}
+     * @returns {Boolean}
      */
     get zUp() {
         return this._worldUp[2] > this._worldUp[0] && this._worldUp[2] > this._worldUp[1];
@@ -21294,7 +21307,7 @@ class ReadableGeometry extends Geometry {
 
     /**
      * @private
-     * @returns {boolean}
+     * @returns {Boolean}
      */
     get isReadableGeometry() {
         return true;
@@ -24491,7 +24504,7 @@ class SAO extends Component {
      * Returns true if SAO is currently possible, where it is supported, enabled, and the current scene state is compatible.
      * Called internally by renderer logic.
      * @private
-     * @returns {boolean}
+     * @returns {Boolean}
      */
     get possible() {
         if (!this._supported) {
@@ -25912,16 +25925,16 @@ class Scene extends Component {
         this.reflectionMaps = {};
 
         /**
-         * The {@link Bitmaps}s in this Scene, each mapped to its {@link Bitmap#id}.
+         * The {@link Bitmap}s in this Scene, each mapped to its {@link Bitmap#id}.
          *
          * @type {{String:Bitmap}}
          */
         this.bitmaps = {};
 
         /**
-         * The {@link Line}s in this Scene, each mapped to its {@link Line#id}.
+         * The {@link LineSet}s in this Scene, each mapped to its {@link LineSet#id}.
          *
-         * @type {{String:Line}}
+         * @type {{String:LineSet}}
          */
         this.lineSets = {};
 
@@ -27846,9 +27859,24 @@ class Scene extends Component {
     }
 }
 
+/**
+ * Texture repeat wrapping mode.
+ * @type {number}
+ */
 const RepeatWrapping = 1000;
+
+/**
+ * Texture clamp-to-edge wrapping mode.
+ * @type {number}
+ */
 const ClampToEdgeWrapping = 1001;
+
+/**
+ * Texture mirrored-repeat wrapping mode.
+ * @type {number}
+ */
 const MirroredRepeatWrapping = 1002;
+
 const NearestFilter = 1003;
 const NearestMipMapNearestFilter = 1004;
 const NearestMipmapNearestFilter = 1004;
@@ -42390,7 +42418,7 @@ class VBOGeometry extends Geometry {
 
     /**
      * @private
-     * @returns {boolean}
+     * @returns {Boolean}
      */
     get isVBOGeometry() {
         return true;
@@ -44439,14 +44467,14 @@ function buildTorusGeometry(cfg = {}) {
  *
  * * Creates a 3D quad containing our bitmap, located and oriented using ````pos````, ````normal```` and ````up```` vectors.
  * * Registered by {@link Bitmap#id} in {@link Scene#bitmaps}.
- * * Created when we use {@link BCFViewpointsPlugin#setViewpoint} to load a BCF viewpoint that contains bitmaps.
+ * * {@link BCFViewpointsPlugin} will save and load Bitmaps in BCF viewpoints.
  *
  * ## Usage
  *
  * In the example below, we'll load the Schependomlaan model, then use
  * an ````Bitmap```` to show a storey plan next to the model.
  *
- * [<img src="http://xeokit.github.io/xeokit-sdk/assets/images/Bitmap_grid.png">](http://xeokit.github.io/xeokit-sdk/examples/#Bitmap_grid)
+ * [<img src="http://xeokit.github.io/xeokit-sdk/assets/images/Bitmap_storeyPlan.png">](http://xeokit.github.io/xeokit-sdk/examples/#Bitmap_storeyPlan)
  *
  * [[Run this example](http://xeokit.github.io/xeokit-sdk/examples/#Bitmap_grid)]
  *
@@ -44486,6 +44514,10 @@ function buildTorusGeometry(cfg = {}) {
 class Bitmap extends Component {
 
     /**
+     * Creates a new Bitmap.
+     *
+     * Registers the Bitmap in {@link Scene#bitmaps}; causes Scene to fire a "bitmapCreated" event.
+     *
      * @constructor
      * @param {Component} [owner]  Owner component. When destroyed, the owner will destroy this ````Bitmap```` as well.
      * @param {*} [cfg]  ````Bitmap```` configuration
@@ -44877,7 +44909,9 @@ class Bitmap extends Component {
     }
 
     /**
-     * @destroy
+     * Destroys this ````Bitmap````.
+     *
+     * Removes the ```Bitmap```` from {@link Scene#bitmaps}; causes Scene to fire a "bitmapDestroyed" event.
      */
     destroy() {
         super.destroy();
@@ -44896,13 +44930,13 @@ class Bitmap extends Component {
  * * Creates a set of 3D line segments.
  * * Registered by {@link LineSet#id} in {@link Scene#lineSets}.
  * * Configure color using the {@link LinesMaterial} located at {@link Scene#linesMaterial}.
- * * Created when we use {@link BCFViewpointsPlugin#setViewpoint} to load a BCF viewpoint that contains lines.
+ * * {@link BCFViewpointsPlugin} will save and load Linesets in BCF viewpoints.
+ *
+ * ## Usage
  *
  * In the example below, we'll load the Schependomlaan model, then use
  * a ````LineSet```` to show a grid underneath the model.
  *
- * <img src="http://xeokit.io/img/docs/Bitmap/BCF_SaveViewpoint_BitmapsAndLines.png">
- *
  * [<img src="http://xeokit.github.io/xeokit-sdk/assets/images/LineSet_grid.png">](http://xeokit.github.io/xeokit-sdk/examples/#LineSet_grid)
  *
  * [[Run this example](http://xeokit.github.io/xeokit-sdk/examples/#LineSet_grid)]
@@ -44926,8 +44960,7 @@ class Bitmap extends Component {
  * const model = xktLoader.load({
  *      id: "myModel",
  *      src: "../assets/models/xkt/v8/ifc/Schependomlaan.ifc.xkt",
- *
- *  position: [0,1,0],
+ *      position: [0,1,0],
  *      edges: true,
  *      saoEnabled: true
  *  });
@@ -44946,15 +44979,19 @@ class Bitmap extends Component {
 class LineSet extends Component {
 
     /**
+     * Creates a new LineSet.
+     *
+     * Registers the LineSet in {@link Scene#lineSets}; causes Scene to fire a "lineSetCreated" event.
+     *
      * @constructor
      * @param {Component} [owner]  Owner component. When destroyed, the owner will destroy this ````LineSet```` as well.
      * @param {*} [cfg]  ````LineSet```` configuration
      * @param {String} [cfg.id] Optional ID, unique among all components in the parent {@link Scene}, generated automatically when omitted.
-     * @param {Number[]} cfg.positions World-space vertex positions.
-     * @param {Number[]} [cfg.indices] Indices
-     * @param {Number[]} [cfg.color=[0,0,0]] The color of this ````LineSet````.
+     * @param {Number[]} cfg.positions World-space 3D vertex positions.
+     * @param {Number[]} [cfg.indices] Indices to connect ````positions```` into line segments. Note that these are separate line segments, not a polyline.
+     * @param {Number[]} [cfg.color=[0,0,0]] The color of this ````LineSet````. This is both emissive and diffuse.
      * @param {Boolean} [cfg.visible=true] Indicates whether or not this ````LineSet```` is visible.
-     * @param {Number} [cfg.opacity=1.0] ````LineSet````'s initial opacity factor, multiplies by the rendered fragment alpha.
+     * @param {Number} [cfg.opacity=1.0] ````LineSet````'s initial opacity factor.
      */
     constructor(owner, cfg = {}) {
 
@@ -44994,7 +45031,7 @@ class LineSet extends Component {
     }
 
     /**
-     * Sets if this ````LineSet```` is visible or not.
+     * Sets if this ````LineSet```` is visible.
      *
      * Default value is ````true````.
      *
@@ -45005,7 +45042,7 @@ class LineSet extends Component {
     }
 
     /**
-     * Gets if this ````LineSet```` is visible or not.
+     * Gets if this ````LineSet```` is visible.
      *
      * Default value is ````true````.
      *
@@ -45016,7 +45053,7 @@ class LineSet extends Component {
     }
 
     /**
-     * Gets the vertex positions of the lines in this ````LineSet````.
+     * Gets the 3D World-space vertex positions of the lines in this ````LineSet````.
      *
      * @returns {Number[]}
      */
@@ -45034,7 +45071,9 @@ class LineSet extends Component {
     }
 
     /**
-     * @destroy
+     * Destroys this ````LineSet````.
+     *
+     * Removes the ```LineSet```` from {@link Scene#lineSets}; causes Scene to fire a "lineSetDestroyed" event.
      */
     destroy() {
         super.destroy();
@@ -45050,19 +45089,46 @@ const tempVec3c$6 = 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.
+ * [<img src="http://xeokit.github.io/xeokit-sdk/assets/images/BCFViewpointsPlugin.png">](http://xeokit.github.io/xeokit-sdk/examples/#BCF_SaveViewpoint)
+ *
+ * * [[Example 1: Saving viewer state to a BCF viewpoint](https://xeokit.github.io/xeokit-sdk/examples/#BCF_SaveViewpoint)]
+ * * [[Example 2: Loading viewer state from a BCF viewpoint](https://xeokit.github.io/xeokit-sdk/examples/#BCF_LoadViewpoint)]
+ *
+ * ## Overview
+ *
+ * BCF is an open standard that enables workflow communications between BIM software tools. An XML schema, called
+ * Building Collaboration Format (BCF), encodes messages that inform one BIM tool of issues found by another.
+ *
+ * A BCF viewpoint captures a viewpoint of a model that highlights an issue. The viewpoint can then be loaded by another
+ * viewer to examine the issue.
+ *
+ * Using this plugin, a xeokit {@link Viewer} can exchange BCF-encoded viewpoints with other BIM software,
+ * allowing us to use the Viewer to report and view issues in BIM models.
+ *
+ * This plugin's viewpoints conform to the <a href="https://github.com/buildingSMART/BCF-API">BCF Version 2.1</a> specification.
+ *
+ * ## Supported BCF Elements
+ *
+ * BCFViewpointsPlugin saves and loads the following state in BCF viewpoints:
+ *
+ * * {@link Camera} position, orientation and projection
+ * * {@link Entity} visibilities and selection states
+ * * {@link SectionPlane}s to slice the model
+ * * {@link LineSet}s to show 3D lines
+ * * {@link Bitmap}s to show images
  *
  * ## 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}
+ * slice the model in half using a {@link SectionPlanesPlugin}, create a grid ground plane using a {@link LineSet} and a 2D
+ * plan view using a {@link Bitmap}, 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)]
+ * * [[Run this example](https://xeokit.github.io/xeokit-sdk/examples/#BCF_SaveViewpoint)]
  *
  * ````javascript
- * import {Viewer, XKTLoaderPlugin, SectionPlanesPlugin, BCFViewpointsPlugin} from "xeokit-sdk.es.js";
+ * import {Viewer, XKTLoaderPlugin, SectionPlanesPlugin,
+ *      LineSet, Bitmap, buildGridGeometry, BCFViewpointsPlugin} from "xeokit-sdk.es.js";
  *
  * // Create a Viewer
  * const viewer = new Viewer({
@@ -45070,6 +45136,12 @@ const tempVec3c$6 = math.vec3();
  *      transparent: true
  * });
  *
+ * // Set camera position and orientation
+ * viewer.scene.camera.eye = [-48.93, 54.54, 50.41];
+ * viewer.scene.camera.look = [0.55, -0.61, -0.55];
+ * viewer.scene.camera.up = [0, -1, 0];
+ * viewer.scene.camera.perspective.fov = 60;
+ *
  * // Add a XKTLoaderPlugin
  * const xktLoader = new XKTLoaderPlugin(viewer);
  *
@@ -45093,15 +45165,37 @@ const tempVec3c$6 = math.vec3();
  *      dir: [0.5, 0.0, 0.5]
  * });
  *
- * // When model is loaded, set camera, select some objects and capture a BCF viewpoint to the console
+ * // Create a bitmap
+ * const bitmap = new Bitmap(viewer.scene, {
+ *     src: "../assets/images/schependomlaanPlanView.png",
+ *      visible: true,
+ *      height: 24.0,
+ *      pos: [-15, 0, -10],
+ *      normal: [0, -1, 0],
+ *      up: [0, 0, 1],
+ *      collidable: false,
+ *      opacity: 1.0,
+ *      clippable: false,
+ *      pickable: true
+ *  });
+ *
+ * // Create a grid ground plane
+ * const geometryArrays = buildGridGeometry({
+ *      size: 60,
+ *      divisions: 10
+ *  });
+ *
+ * new LineSet(viewer.scene, {
+ *      positions: geometryArrays.positions,
+ *      indices: geometryArrays.indices,
+ *      position: [10,0,10],
+ *      clippable: false
+ *  });
+ *
+ * // When model is loaded, 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",
@@ -45118,6 +45212,57 @@ const tempVec3c$6 = math.vec3();
  * });
  * ````
  *
+ * The saved BCF viewpoint would look something like below. Note that some elements are truncated for brevity.
+ *
+ * ````json
+ * {
+ *      "perspective_camera": {
+ *          "camera_view_point": { "x": -48.93, "y": 54.54, "z": 50.41 },
+ *          "camera_direction": { "x": 0.55, "y": -0.61, "z": -0.55},
+ *          "camera_up_vector": { "x": 0.37, "y": -0.41, "z": 0.83 },
+ *          "field_of_view": 60.0
+ *      },
+ *      "lines": [{
+ *          "start_point": { "x": 1.0, "y": 1.0, "z": 1.0 },
+ *          "end_point": { "x": 0.0, "y": 0.0, "z": 0.0 },
+ *          //...(truncated)
+ *      }],
+ *      "bitmaps": [{
+ *          "bitmap_type": "png",
+ *          "bitmap_data": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAB9AAAAdp...", //...(truncated)
+ *          "location": { "x": -15, "y": 10, "z": 0 },
+ *          "normal": { "x": 0, "y": 0, "z": -1 },
+ *          "up": { "x": 0, "y": -1, "z": 0 },
+ *          "height": 24
+ *      }],
+ *      "clipping_planes": [{
+ *          "location": { "x": 0.0, "y": 0.0, "z": 0.0 },
+ *          "direction": { "x": 0.5, "y": 0.0, "z": 0.5 }
+ *      }],
+ *      "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/v3.2"
+ *                  },
+ *                  //...
+ *              ]
+ *          },
+ *          "selection": [{
+ *                  "ifc_guid": "4$cshxZO9AJBebsni$z9Yk",
+ *              },
+ *              //...
+ *          ]
+ *      }
+ * }
+ * ````
+ *
  * ## Saving View Setup Hints
  *
  * BCFViewpointsPlugin can optionally save hints in the viewpoint, which indicate how to set up the view when
@@ -45161,7 +45306,7 @@ const tempVec3c$6 = math.vec3();
  * });
  * ````
  *
- * ## Dealing With Loaded Models That Are Not in the Viewpoint
+ * ## 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
@@ -45270,8 +45415,7 @@ class BCFViewpointsPlugin extends Plugin {
     /**
      * 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}.
+     * See ````BCFViewpointsPlugin```` class comments for more info.
      *
      * @param {*} [options] Options for getting the viewpoint.
      * @param {Boolean} [options.spacesVisible=false] Indicates whether ````IfcSpace```` types should be forced visible in the viewpoint.
@@ -45284,84 +45428,6 @@ class BCFViewpointsPlugin extends Plugin {
      * 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
-     *      },
-     *      lineSets: [{
-     *          start_point: {
-     *              x: 1.0,
-     *              y: 1.0,
-     *              z: 1.0
-     *          },
-     *          end_point: {
-     *              x: 0.0,
-     *              y: 0.0,
-     *              z: 0.0
-     *          }
-     *     }],
-     *     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;
@@ -45683,7 +45749,9 @@ class BCFViewpointsPlugin extends Plugin {
             });
             new LineSet(scene, {
                 positions,
-                indices
+                indices,
+                clippable: false,
+                collidable: true
             });
         }
 
@@ -45696,6 +45764,7 @@ class BCFViewpointsPlugin extends Plugin {
                 let location = xyzObjectToArray(e.location, tempVec3a$X);
                 let normal = xyzObjectToArray(e.normal, tempVec3b$9);
                 let up = xyzObjectToArray(e.up, tempVec3c$6);
+                let height = e.height || 1;
                 if (!bitmap_type) {
                     return;
                 }
@@ -45721,7 +45790,10 @@ class BCFViewpointsPlugin extends Plugin {
                     type: bitmap_type,
                     pos: location,
                     normal: normal,
-                    up: up
+                    up: up,
+                    clippable: false,
+                    collidable: true,
+                    height
                 });
             });
         }
@@ -46360,7 +46432,7 @@ class DistanceMeasurement extends Component {
     /**
      * Sets whether this DistanceMeasurement is visible or not.
      *
-     * @type Boolean
+     * @type {Boolean}
      */
     set visible(value) {
         value = value !== undefined ? Boolean(value) : this.plugin.defaultVisible;
@@ -46381,7 +46453,7 @@ class DistanceMeasurement extends Component {
     /**
      * Gets whether this DistanceMeasurement is visible or not.
      *
-     * @type Boolean
+     * @type {Boolean}
      */
     get visible() {
         return this._visible;
@@ -46562,7 +46634,7 @@ class DistanceMeasurementsControl extends Component {
 
     /** Gets if this DistanceMeasurementsControl is currently active, where it is responding to input.
      *
-     * @returns {boolean}
+     * @returns {Boolean}
      */
     get active() {
         return this._active;
@@ -54294,7 +54366,7 @@ class TrianglesBatchingLayer {
      *
      * @param lenPositions Number of positions we'd like to create in the portion.
      * @param lenIndices Number of indices we'd like to create in this portion.
-     * @returns {boolean} True if OK to create another portion.
+     * @returns {Boolean} True if OK to create another portion.
      */
     canCreatePortion(lenPositions, lenIndices) {
         if (this._finalized) {
@@ -63724,7 +63796,7 @@ class LinesBatchingLayer {
      *
      * @param lenPositions Number of positions we'd like to create in the portion.
      * @param lenIndices Number of indices we'd like to create in this portion.
-     * @returns {boolean} True if OK to create another portion.
+     * @returns {Boolean} True if OK to create another portion.
      */
     canCreatePortion(lenPositions, lenIndices) {
         if (this._finalized) {
@@ -67669,7 +67741,7 @@ class PointsBatchingLayer {
      * Tests if there is room for another portion in this PointsBatchingLayer.
      *
      * @param lenPositions Number of positions we'd like to create in the portion.
-     * @returns {boolean} True if OK to create another portion.
+     * @returns {Boolean} True if OK to create another portion.
      */
     canCreatePortion(lenPositions) {
         if (this._finalized) {
@@ -72807,6 +72879,34 @@ class SceneModel  {
     }
 }
 
+const Cache = {
+
+    enabled: false,
+    files: {},
+
+    add: function (key, file) {
+        if (this.enabled === false) {
+            return;
+        }
+        this.files[key] = file;
+    },
+
+    get: function (key) {
+        if (this.enabled === false) {
+            return;
+        }
+        return this.files[key];
+    },
+
+    remove: function (key) {
+        delete this.files[key];
+    },
+
+    clear: function () {
+        this.files = {};
+    }
+};
+
 class LoadingManager {
 
     constructor(onLoad, onProgress, onError) {
@@ -72944,138 +73044,6 @@ class Loader {
     }
 }
 
-/**
- * @author Deepkolos / https://github.com/deepkolos
- */
-
-class WorkerPool$1 {
-
-    constructor(pool = 4) {
-        this.pool = pool;
-        this.queue = [];
-        this.workers = [];
-        this.workersResolve = [];
-        this.workerStatus = 0;
-    }
-
-    _initWorker(workerId) {
-        if (!this.workers[workerId]) {
-            const worker = this.workerCreator();
-            worker.addEventListener('message', this._onMessage.bind(this, workerId));
-            this.workers[workerId] = worker;
-        }
-    }
-
-    _getIdleWorker() {
-        for (let i = 0; i < this.pool; i++)
-            if (!(this.workerStatus & (1 << i))) return i;
-        return -1;
-    }
-
-    _onMessage(workerId, msg) {
-        const resolve = this.workersResolve[workerId];
-        resolve && resolve(msg);
-        if (this.queue.length) {
-            const {resolve, msg, transfer} = this.queue.shift();
-            this.workersResolve[workerId] = resolve;
-            this.workers[workerId].postMessage(msg, transfer);
-        } else {
-            this.workerStatus ^= 1 << workerId;
-        }
-    }
-
-    setWorkerCreator(workerCreator) {
-        this.workerCreator = workerCreator;
-    }
-
-    setWorkerLimit(pool) {
-        this.pool = pool;
-    }
-
-    postMessage(msg, transfer) {
-        return new Promise((resolve) => {
-            const workerId = this._getIdleWorker();
-            if (workerId !== -1) {
-                this._initWorker(workerId);
-                this.workerStatus |= 1 << workerId;
-                this.workersResolve[workerId] = resolve;
-                this.workers[workerId].postMessage(msg, transfer);
-            } else {
-                this.queue.push({resolve, msg, transfer});
-            }
-        });
-    }
-
-    destroy() {
-
-        this.workers.forEach((worker) => worker.terminate());
-        this.workersResolve.length = 0;
-        this.workers.length = 0;
-        this.queue.length = 0;
-        this.workerStatus = 0;
-
-    }
-
-}
-
-/**
- * Transcodes texture data.
- *
- * A {@link SceneModel} configured with an appropriate TextureTranscoder will allow us to add textures from
- * transcoded buffers or files. For a concrete example, see {@link VBOSceneModel}, which can be configured with
- * a {@link KTX2TextureTranscoder}, which allows us to add textures from KTX2 buffers and files.
- *
- * @interface
- */
-class TextureTranscoder {
-
-    /**
-     * Transcodes texture data from transcoded buffers into a {@link Texture2D}.
-     *
-     * @param {ArrayBuffer[]} buffers Transcoded texture data. Given as an array of buffers so that we can support
-     * multi-image textures, such as cube maps.
-     * @param {*} config Transcoding options.
-     * @param {Texture2D} texture The texture to load.
-     * @returns {Promise} Resolves when the texture has loaded.
-     */
-    transcode(buffers, texture, config = {}) {
-    }
-
-    /**
-     * Destroys this transcoder.
-     */
-    destroy() {
-    }
-}
-
-const Cache = {
-
-    enabled: false,
-    files: {},
-
-    add: function (key, file) {
-        if (this.enabled === false) {
-            return;
-        }
-        this.files[key] = file;
-    },
-
-    get: function (key) {
-        if (this.enabled === false) {
-            return;
-        }
-        return this.files[key];
-    },
-
-    remove: function (key) {
-        delete this.files[key];
-    },
-
-    clear: function () {
-        this.files = {};
-    }
-};
-
 const loading = {};
 
 class FileLoader extends Loader {
@@ -73231,6 +73199,80 @@ class FileLoader extends Loader {
     }
 }
 
+/**
+ * @author Deepkolos / https://github.com/deepkolos
+ */
+
+class WorkerPool$1 {
+
+    constructor(pool = 4) {
+        this.pool = pool;
+        this.queue = [];
+        this.workers = [];
+        this.workersResolve = [];
+        this.workerStatus = 0;
+    }
+
+    _initWorker(workerId) {
+        if (!this.workers[workerId]) {
+            const worker = this.workerCreator();
+            worker.addEventListener('message', this._onMessage.bind(this, workerId));
+            this.workers[workerId] = worker;
+        }
+    }
+
+    _getIdleWorker() {
+        for (let i = 0; i < this.pool; i++)
+            if (!(this.workerStatus & (1 << i))) return i;
+        return -1;
+    }
+
+    _onMessage(workerId, msg) {
+        const resolve = this.workersResolve[workerId];
+        resolve && resolve(msg);
+        if (this.queue.length) {
+            const {resolve, msg, transfer} = this.queue.shift();
+            this.workersResolve[workerId] = resolve;
+            this.workers[workerId].postMessage(msg, transfer);
+        } else {
+            this.workerStatus ^= 1 << workerId;
+        }
+    }
+
+    setWorkerCreator(workerCreator) {
+        this.workerCreator = workerCreator;
+    }
+
+    setWorkerLimit(pool) {
+        this.pool = pool;
+    }
+
+    postMessage(msg, transfer) {
+        return new Promise((resolve) => {
+            const workerId = this._getIdleWorker();
+            if (workerId !== -1) {
+                this._initWorker(workerId);
+                this.workerStatus |= 1 << workerId;
+                this.workersResolve[workerId] = resolve;
+                this.workers[workerId].postMessage(msg, transfer);
+            } else {
+                this.queue.push({resolve, msg, transfer});
+            }
+        });
+    }
+
+    destroy() {
+
+        this.workers.forEach((worker) => worker.terminate());
+        this.workersResolve.length = 0;
+        this.workers.length = 0;
+        this.queue.length = 0;
+        this.workerStatus = 0;
+
+    }
+
+}
+
 const KTX2TransferSRGB = 2;
 const KTX2_ALPHA_PREMULTIPLIED = 1;
 
@@ -77114,848 +77156,6 @@ class VBOSceneModel extends Component {
     }
 }
 
-/**
- * @private
- */
-class GLTFSceneGraphLoader {
-
-    constructor(cfg) { // TODO: Loading options fallbacks on loader, eg. handleGLTFNode etc
-    }
-
-    load(plugin, modelNode, src, options, ok, error) {
-        options = options || {};
-        var spinner = modelNode.scene.canvas.spinner;
-        spinner.processes++;
-        loadGLTF$1(plugin, modelNode, src, options, function () {
-                spinner.processes--;
-                core.scheduleTask(function () {
-                    modelNode.scene.fire("modelLoaded", modelNode.id); // FIXME: Assumes listeners know order of these two events
-                    modelNode.fire("loaded", true, false);
-                });
-                if (ok) {
-                    ok();
-                }
-            },
-            function (msg) {
-                spinner.processes--;
-                modelNode.error(msg);
-                if (error) {
-                    error(msg);
-                }
-                modelNode.fire("error", msg);
-            });
-    }
-
-    parse(plugin, modelNode, gltf, options, ok, error) {
-        options = options || {};
-        var spinner = modelNode.scene.canvas.spinner;
-        spinner.processes++;
-        parseGLTF$2(plugin, gltf, "", options, modelNode, function () {
-                spinner.processes--;
-                modelNode.scene.fire("modelLoaded", modelNode.id); // FIXME: Assumes listeners know order of these two events
-                modelNode.fire("loaded", true, false);
-                if (ok) {
-                    ok();
-                }
-            },
-            function (msg) {
-                spinner.processes--;
-                modelNode.error(msg);
-                modelNode.fire("error", msg);
-                if (error) {
-                    error(msg);
-                }
-            });
-    }
-}
-
-
-var loadGLTF$1 = (function () {
-    return function (plugin, modelNode, src, options, ok, error) {
-        plugin.dataSource.getGLTF(src, function (json) { // OK
-                options.basePath = getBasePath(src);
-                parseGLTF$2(plugin, json, src, options, modelNode, ok, error);
-            },
-            error);
-    };
-
-    function getBasePath(src) {
-        var i = src.lastIndexOf("/");
-        return (i !== 0) ? src.substring(0, i + 1) : "";
-    }
-})();
-
-var parseGLTF$2 = (function () {
-
-    const WEBGL_COMPONENT_TYPES = {
-        5120: Int8Array,
-        5121: Uint8Array,
-        5122: Int16Array,
-        5123: Uint16Array,
-        5125: Uint32Array,
-        5126: Float32Array
-    };
-
-    const WEBGL_TYPE_SIZES = {
-        'SCALAR': 1,
-        'VEC2': 2,
-        'VEC3': 3,
-        'VEC4': 4,
-        'MAT2': 4,
-        'MAT3': 9,
-        'MAT4': 16
-    };
-
-    return function (plugin, json, src, options, modelNode, ok) {
-        modelNode.clear();
-        var ctx = {
-            src: src,
-            loadBuffer: options.loadBuffer,
-            basePath: options.basePath,
-            prioritizeGLTFNode: options.prioritizeGLTFNode,
-            handleGLTFNode: options.handleGLTFNode,
-            ignoreMaterials: !!options.ignoreMaterials,
-            edgeThreshold: options.edgeThreshold,
-            readableGeometry: !!options.readableGeometry,
-            json: json,
-            scene: modelNode.scene,
-            plugin: plugin,
-            modelNode: modelNode,
-            modelNodeProps: {
-                visible: modelNode.visible,
-                culled: modelNode.culled,
-                xrayed: modelNode.xrayed,
-                highlighted: modelNode.highlighted,
-                selected: modelNode.selected,
-                outlined: modelNode.outlined,
-                clippable: modelNode.clippable,
-                pickable: modelNode.pickable,
-                collidable: modelNode.collidable,
-                castsShadow: modelNode.castsShadow,
-                receivesShadow: modelNode.receivesShadow,
-                colorize: modelNode.colorize,
-                opacity: modelNode.opacity,
-                edges: modelNode.edges
-            }
-        };
-
-        modelNode.scene.loading++; // Disables (re)compilation
-
-        loadBuffers(ctx, function () {
-
-            loadBufferViews(ctx);
-            loadAccessors(ctx);
-            loadTextures(ctx);
-            loadMaterials(ctx);
-            loadMeshes(ctx);
-            loadDefaultScene(ctx);
-
-            modelNode.scene.loading--; // Re-enables (re)compilation
-
-            ok();
-        });
-    };
-
-    function loadBuffers(ctx, ok) {
-        var buffers = ctx.json.buffers;
-        if (buffers) {
-            var numToLoad = buffers.length;
-            for (var i = 0, len = buffers.length; i < len; i++) {
-                loadBuffer(ctx, buffers[i], function () {
-                    if (--numToLoad === 0) {
-                        ok();
-                    }
-                }, function (msg) {
-                    ctx.plugin.error(msg);
-                    if (--numToLoad === 0) {
-                        ok();
-                    }
-                });
-            }
-        } else {
-            ok();
-        }
-    }
-
-    function loadBuffer(ctx, bufferInfo, ok, err) {
-        var uri = bufferInfo.uri;
-        if (uri) {
-            ctx.plugin.dataSource.getArrayBuffer(ctx.src, uri, function (data) {
-                    bufferInfo._buffer = data;
-                    ok();
-                },
-                err);
-        } else {
-            err('gltf/handleBuffer missing uri in ' + JSON.stringify(bufferInfo));
-        }
-    }
-
-    function loadBufferViews(ctx) {
-        var bufferViewsInfo = ctx.json.bufferViews;
-        if (bufferViewsInfo) {
-            for (var i = 0, len = bufferViewsInfo.length; i < len; i++) {
-                loadBufferView(ctx, bufferViewsInfo[i]);
-            }
-        }
-    }
-
-    function loadBufferView(ctx, bufferViewInfo) {
-
-        var buffer = ctx.json.buffers[bufferViewInfo.buffer];
-
-        bufferViewInfo._typedArray = null;
-
-        var byteLength = bufferViewInfo.byteLength || 0;
-        var byteOffset = bufferViewInfo.byteOffset || 0;
-
-        bufferViewInfo._buffer = buffer._buffer.slice(byteOffset, byteOffset + byteLength);
-    }
-
-    function loadAccessors(ctx) {
-        var accessorsInfo = ctx.json.accessors;
-        if (accessorsInfo) {
-            for (var i = 0, len = accessorsInfo.length; i < len; i++) {
-                loadAccessor(ctx, accessorsInfo[i]);
-            }
-        }
-    }
-
-    function loadAccessor(ctx, accessorInfo) {
-        var bufferViewInfo = ctx.json.bufferViews[accessorInfo.bufferView];
-        var itemSize = WEBGL_TYPE_SIZES[accessorInfo.type];
-        var TypedArray = WEBGL_COMPONENT_TYPES[accessorInfo.componentType];
-
-        // For VEC3: itemSize is 3, elementBytes is 4, itemBytes is 12.
-        var elementBytes = TypedArray.BYTES_PER_ELEMENT;
-        var itemBytes = elementBytes * itemSize;
-
-        // The buffer is not interleaved if the stride is the item size in bytes.
-        if (accessorInfo.byteStride && accessorInfo.byteStride !== itemBytes) ; else {
-            accessorInfo._typedArray = new TypedArray(bufferViewInfo._buffer, accessorInfo.byteOffset || 0, accessorInfo.count * itemSize);
-            accessorInfo._itemSize = itemSize;
-        }
-    }
-
-
-    function loadTextures(ctx) {
-        var texturesInfo = ctx.json.textures;
-        if (texturesInfo) {
-            for (var i = 0, len = texturesInfo.length; i < len; i++) {
-                loadTexture(ctx, texturesInfo[i]);
-            }
-        }
-    }
-
-    function loadTexture(ctx, textureInfo) {
-        let uri = ctx.json.images[textureInfo.source].uri;
-        if (uri && !uri.match(/^data:(.*?)(;base64)?,(.*)$/)) {
-            uri = ctx.basePath + uri;
-        }
-        textureInfo._texture = new Texture(ctx.modelNode, {
-            src: uri,
-            flipY: !!textureInfo.flipY,
-            //encoding: "sRGB"
-            encoding: "linear"
-        });
-    }
-
-    function loadMaterials(ctx) {
-        var materialsInfo = ctx.json.materials;
-        if (materialsInfo) {
-            var materialInfo;
-            var material;
-            for (var i = 0, len = materialsInfo.length; i < len; i++) {
-                materialInfo = materialsInfo[i];
-                material = loadMaterial(ctx, materialInfo);
-                materialInfo._material = material;
-            }
-        }
-    }
-
-    function loadMaterial(ctx, materialInfo) {
-
-        var json = ctx.json;
-        var cfg = {};
-        var textureInfo;
-
-        // Common attributes
-
-        var normalTexture = materialInfo.normalTexture;
-        if (normalTexture) {
-            textureInfo = json.textures[normalTexture.index];
-            if (textureInfo) {
-                cfg.normalMap = textureInfo._texture;
-                //cfg.normalMap.encoding = "linear";
-            }
-        }
-
-        var occlusionTexture = materialInfo.occlusionTexture;
-        if (occlusionTexture) {
-            textureInfo = json.textures[occlusionTexture.index];
-            if (textureInfo) {
-                cfg.occlusionMap = textureInfo._texture;
-            }
-        }
-
-        var emissiveTexture = materialInfo.emissiveTexture;
-        if (emissiveTexture) {
-            textureInfo = json.textures[emissiveTexture.index];
-            if (textureInfo) {
-                cfg.emissiveMap = textureInfo._texture;
-                //cfg.emissiveMap.encoding = "sRGB";
-            }
-        }
-
-        var emissiveFactor = materialInfo.emissiveFactor;
-        if (emissiveFactor) {
-            cfg.emissive = emissiveFactor;
-        }
-
-        cfg.backfaces = !!materialInfo.doubleSided;
-
-        var alphaMode = materialInfo.alphaMode;
-        switch (alphaMode) {
-            case "NORMAL_OPAQUE":
-                cfg.alphaMode = "opaque";
-                break;
-            case "MASK":
-                cfg.alphaMode = "mask";
-                break;
-            case "BLEND":
-                cfg.alphaMode = "blend";
-                break;
-        }
-
-        var alphaCutoff = materialInfo.alphaCutoff;
-        if (alphaCutoff !== undefined) {
-            cfg.alphaCutoff = alphaCutoff;
-        }
-
-        var extensions = materialInfo.extensions;
-        if (extensions) {
-
-            // Specular PBR material
-
-            var specularPBR = extensions["KHR_materials_pbrSpecularGlossiness"];
-            if (specularPBR) {
-
-                var diffuseFactor = specularPBR.diffuseFactor;
-                if (diffuseFactor !== null && diffuseFactor !== undefined) {
-                    cfg.diffuse = diffuseFactor.slice(0, 3);
-                    cfg.alpha = diffuseFactor[3];
-                }
-
-                var diffuseTexture = specularPBR.diffuseTexture;
-                if (diffuseTexture) {
-                    textureInfo = json.textures[diffuseTexture.index];
-                    if (textureInfo) {
-                        cfg.diffuseMap = textureInfo._texture;
-                        //cfg.diffuseMap.encoding = "sRGB";
-                    }
-                }
-
-                var specularFactor = specularPBR.specularFactor;
-                if (specularFactor !== null && specularFactor !== undefined) {
-                    cfg.specular = specularFactor.slice(0, 3);
-                }
-
-                var glossinessFactor = specularPBR.glossinessFactor;
-                if (glossinessFactor !== null && glossinessFactor !== undefined) {
-                    cfg.glossiness = glossinessFactor;
-                }
-
-                var specularGlossinessTexture = specularPBR.specularGlossinessTexture;
-                if (specularGlossinessTexture) {
-                    textureInfo = json.textures[specularGlossinessTexture.index];
-                    if (textureInfo) {
-                        cfg.specularGlossinessMap = textureInfo._texture;
-                        //cfg.specularGlossinessMap.encoding = "linear";
-                    }
-                }
-
-                return new SpecularMaterial(ctx.modelNode, cfg);
-            }
-
-            // Common Phong, Blinn, Lambert or Constant materials
-
-            var common = extensions["KHR_materials_common"];
-            if (common) {
-
-                var technique = common.technique;
-                var values = common.values || {};
-
-                var blinn = technique === "BLINN";
-                var phong = technique === "PHONG";
-                var lambert = technique === "LAMBERT";
-
-                var shininess = values.shininess;
-                if ((blinn || phong) && shininess !== null && shininess !== undefined) {
-                    cfg.shininess = shininess;
-                } else {
-                    cfg.shininess = 0;
-                }
-                var texture;
-                var diffuse = values.diffuse;
-                if (diffuse && (blinn || phong || lambert)) {
-                    if (utils.isString(diffuse)) {
-                        texture = json.textures[diffuse];
-                        if (texture) {
-                            cfg.diffuseMap = texture;
-                            //  cfg.diffuseMap.encoding = "sRGB";
-                        }
-                    } else {
-                        cfg.diffuse = diffuse.slice(0, 3);
-                    }
-                } else {
-                    cfg.diffuse = [0, 0, 0];
-                }
-
-                var specular = values.specular;
-                if (specular && (blinn || phong)) {
-                    if (utils.isString(specular)) {
-                        texture = json.textures[specular];
-                        if (texture) {
-                            cfg.specularMap = texture;
-                        }
-                    } else {
-                        cfg.specular = specular.slice(0, 3);
-                    }
-                } else {
-                    cfg.specular = [0, 0, 0];
-                }
-
-                var emission = values.emission;
-                if (emission) {
-                    if (utils.isString(emission)) {
-                        texture = json.textures[emission];
-                        if (texture) {
-                            cfg.emissiveMap = texture;
-                        }
-                    } else {
-                        cfg.emissive = emission.slice(0, 3);
-                    }
-                } else {
-                    cfg.emissive = [0, 0, 0];
-                }
-
-                var transparency = values.transparency;
-                if (transparency !== null && transparency !== undefined) {
-                    cfg.alpha = transparency;
-                } else {
-                    cfg.alpha = 1.0;
-                }
-
-                values.transparent;
-
-                return new PhongMaterial(ctx.scene, cfg);
-            }
-        }
-
-        // Metallic PBR naterial
-
-        var metallicPBR = materialInfo.pbrMetallicRoughness;
-        if (metallicPBR) {
-
-            var baseColorFactor = metallicPBR.baseColorFactor;
-            if (baseColorFactor) {
-                cfg.baseColor = baseColorFactor.slice(0, 3);
-                cfg.alpha = baseColorFactor[3];
-            }
-
-            var colorTexture = metallicPBR.colorTexture;
-            if (colorTexture) {
-                textureInfo = json.textures[colorTexture.index];
-                if (textureInfo) {
-                    cfg.baseColorMap = textureInfo._texture;
-                    //cfg.baseColorMap.encoding = "sRGB";
-                }
-            }
-
-            var metallicFactor = metallicPBR.metallicFactor;
-            if (metallicFactor !== null && metallicFactor !== undefined) {
-                cfg.metallic = metallicFactor;
-            }
-
-            var roughnessFactor = metallicPBR.roughnessFactor;
-            if (roughnessFactor !== null && roughnessFactor !== undefined) {
-                cfg.roughness = roughnessFactor;
-            }
-
-            var metallicRoughnessTexture = metallicPBR.metallicRoughnessTexture;
-            if (metallicRoughnessTexture) {
-                textureInfo = json.textures[metallicRoughnessTexture.index];
-                if (textureInfo) {
-                    cfg.metallicRoughnessMap = textureInfo._texture;
-                    // cfg.metallicRoughnessMap.encoding = "linear";
-                }
-            }
-
-            return new MetallicMaterial(ctx.scene, cfg);
-        }
-
-        // Default material
-
-        return new PhongMaterial(ctx.scene, cfg);
-    }
-
-    function loadMeshes(ctx) {
-        var meshes = ctx.json.meshes;
-        if (meshes) {
-            for (var i = 0, len = meshes.length; i < len; i++) {
-                loadMesh(ctx, meshes[i]);
-            }
-        }
-    }
-
-    function loadMesh(ctx, meshInfo) {
-        var json = ctx.json;
-        var mesh = [];
-        var primitivesInfo = meshInfo.primitives;
-        var materialIndex;
-        var materialInfo;
-        var accessorInfo;
-        var attributes;
-
-        if (primitivesInfo) {
-
-            var primitiveInfo;
-            var indicesIndex;
-            var positionsIndex;
-            var normalsIndex;
-            var uv0Index;
-            var geometryCfg;
-            var meshCfg;
-            var geometry;
-
-            for (var i = 0, len = primitivesInfo.length; i < len; i++) {
-                primitiveInfo = primitivesInfo[i];
-                if (primitiveInfo.mode < 4 ) {
-                    continue;
-                }
-                geometryCfg = {
-                    primitive: "triangles",
-                    compressGeometry: true,
-                    edgeThreshold: ctx.edgeThreshold
-                };
-
-                indicesIndex = primitiveInfo.indices;
-
-                if (indicesIndex !== null && indicesIndex !== undefined) {
-                    accessorInfo = json.accessors[indicesIndex];
-                    geometryCfg.indices = accessorInfo._typedArray;
-                }
-
-                attributes = primitiveInfo.attributes;
-                if (!attributes) {
-                    continue;
-                }
-
-                positionsIndex = attributes.POSITION;
-
-                if (positionsIndex !== null && positionsIndex !== undefined) {
-                    accessorInfo = json.accessors[positionsIndex];
-                    geometryCfg.positions = accessorInfo._typedArray;
-                }
-
-                normalsIndex = attributes.NORMAL;
-
-                if (normalsIndex !== null && normalsIndex !== undefined) {
-                    accessorInfo = json.accessors[normalsIndex];
-                    geometryCfg.normals = accessorInfo._typedArray;
-                }
-
-                uv0Index = attributes.TEXCOORD_0;
-
-                if (uv0Index !== null && uv0Index !== undefined) {
-                    accessorInfo = json.accessors[uv0Index];
-                    geometryCfg.uv = accessorInfo._typedArray;
-                }
-
-                meshCfg = {};
-
-                if (ctx.readableGeometry) {
-                    geometry = new ReadableGeometry(ctx.modelNode, geometryCfg);
-                } else {
-                    geometry = new VBOGeometry(ctx.modelNode, geometryCfg);
-                }
-
-                meshCfg.geometry = geometry;
-
-                materialIndex = primitiveInfo.material;
-                if (materialIndex !== null && materialIndex !== undefined) {
-                    materialInfo = json.materials[materialIndex];
-                    if (materialInfo) {
-                        meshCfg.material = materialInfo._material;
-                    }
-                }
-
-                mesh.push(meshCfg);
-            }
-        }
-        meshInfo._mesh = mesh;
-    }
-
-    function loadDefaultScene(ctx) {
-        var json = ctx.json;
-        var scene = json.scene || 0;
-        var defaultSceneInfo = json.scenes[scene];
-        if (!defaultSceneInfo) {
-            error(ctx, "glTF has no default scene");
-            return;
-        }
-        loadScene(ctx, defaultSceneInfo);
-    }
-
-    function loadScene(ctx, sceneInfo) {
-        var nodes = sceneInfo.nodes;
-        if (!nodes) {
-            return;
-        }
-        var json = ctx.json;
-        var glTFNode;
-        for (var i = 0, len = nodes.length; i < len; i++) {
-            glTFNode = json.nodes[nodes[i]];
-            if (!glTFNode) {
-                error(ctx, "Node not found: " + i);
-                continue;
-            }
-            loadNode(ctx, glTFNode, null, null);
-        }
-    }
-
-    function loadNode(ctx, glTFNode, matrix, parent) {
-
-        parent = parent || ctx.modelNode;
-
-        var createEntity;
-
-        if (ctx.prioritizeGLTFNode) {
-            const priority = ctx.prioritizeGLTFNode(ctx.modelNode.id, glTFNode);
-            if (priority === undefined || priority === null) {
-                return;
-            }
-        }
-
-        if (ctx.handleGLTFNode) {
-            var actions = {};
-            if (!ctx.handleGLTFNode(ctx.modelNode.id, glTFNode, actions)) {
-                return;
-            }
-            if (actions.createEntity) {
-                createEntity = actions.createEntity;
-            }
-        }
-
-        const json = ctx.json;
-        const modelNode = ctx.modelNode;
-        const hasChildNodes = glTFNode.children && glTFNode.children.length > 0;
-
-        var localMatrix;
-
-        if (glTFNode.matrix) {
-            localMatrix = glTFNode.matrix;
-            if (matrix) {
-                matrix = math.mulMat4(matrix, localMatrix, math.mat4());
-            } else {
-                matrix = localMatrix;
-            }
-        }
-
-        if (glTFNode.translation) {
-            localMatrix = math.translationMat4v(glTFNode.translation);
-            if (matrix) {
-                matrix = math.mulMat4(matrix, localMatrix, localMatrix);
-            } else {
-                matrix = localMatrix;
-            }
-        }
-
-        if (glTFNode.rotation) {
-            localMatrix = math.quaternionToMat4(glTFNode.rotation);
-            if (matrix) {
-                matrix = math.mulMat4(matrix, localMatrix, localMatrix);
-            } else {
-                matrix = localMatrix;
-            }
-        }
-
-        if (glTFNode.scale) {
-            localMatrix = math.scalingMat4v(glTFNode.scale);
-            if (matrix) {
-                matrix = math.mulMat4(matrix, localMatrix, localMatrix);
-            } else {
-                matrix = localMatrix;
-            }
-        }
-
-        if (glTFNode.mesh !== undefined) {
-
-            var meshInfo = json.meshes[glTFNode.mesh];
-
-            if (meshInfo) {
-
-                var meshesInfo = meshInfo._mesh;
-                var meshesInfoMesh;
-                var mesh;
-                var numMeshes = meshesInfo.length;
-
-                if (!createEntity && numMeshes > 0 && !hasChildNodes) {
-
-                    // Case 1: Not creating object, node has meshes, node has no child nodes
-
-                    for (var i = 0, len = numMeshes; i < len; i++) {
-                        meshesInfoMesh = meshesInfo[i];
-                        let meshCfg = {
-                            geometry: meshesInfoMesh.geometry,
-                            matrix: matrix
-                        };
-                        utils.apply(ctx.modelNodeProps, meshCfg);
-                        meshCfg.material = meshesInfoMesh.material;
-                        mesh = new Mesh(modelNode, meshCfg);
-                        parent.addChild(mesh, false); // Don't automatically inherit properties
-                    }
-                    return;
-                }
-
-                if (createEntity && numMeshes === 1 && !hasChildNodes) {
-
-                    // Case 2: Creating object, node has one mesh, node has no child nodes
-
-                    meshesInfoMesh = meshesInfo[0];
-                    let meshCfg = {
-                        geometry: meshesInfoMesh.geometry,
-                        matrix: matrix
-                    };
-                    utils.apply(ctx.modelNodeProps, meshCfg);
-                    meshCfg.material = meshesInfoMesh.material;
-                    utils.apply(createEntity, meshCfg);
-                    mesh = new Mesh(modelNode, meshCfg);
-                    parent.addChild(mesh, false); // Don't automatically inherit properties
-                    return;
-                }
-
-                if (createEntity && numMeshes > 0 && !hasChildNodes) {
-
-                    // Case 3: Creating object, node has meshes, node has no child nodes
-
-                    let nodeCfg = {
-                        matrix: matrix
-                    };
-                    utils.apply(ctx.modelNodeProps, nodeCfg);
-                    utils.apply(createEntity, nodeCfg);
-                    let childNode = new Node$1(modelNode, nodeCfg);
-                    parent.addChild(childNode, false);
-                    for (let i = 0, len = numMeshes; i < len; i++) {
-                        meshesInfoMesh = meshesInfo[i];
-                        let meshCfg = {
-                            geometry: meshesInfoMesh.geometry
-                        };
-                        utils.apply(ctx.modelNodeProps, meshCfg);
-                        meshCfg.material = meshesInfoMesh.material;
-                        utils.apply(createEntity, meshCfg);
-                        meshCfg.id = null; // Avoid ID clash with parent Node
-                        mesh = new Mesh(modelNode, meshCfg);
-                        childNode.addChild(mesh, false);
-                    }
-                    return;
-                }
-
-                if (!createEntity && numMeshes > 0 && hasChildNodes) {
-
-                    // Case 4: Not creating object, node has meshes, node has child nodes
-
-                    let nodeCfg = {
-                        matrix: matrix
-                    };
-                    utils.apply(ctx.modelNodeProps, nodeCfg);
-                    let childNode = new Node$1(modelNode, nodeCfg);
-                    parent.addChild(childNode, false);
-                    for (let i = 0, len = numMeshes; i < len; i++) {
-                        meshesInfoMesh = meshesInfo[i];
-                        let meshCfg = {
-                            geometry: meshesInfoMesh.geometry
-                        };
-                        utils.apply(nodeCfg, meshCfg);
-                        meshCfg.id = null; // Avoid ID clash with parent Node
-                        meshCfg.matrix = null; // Node has matrix
-                        meshCfg.material = meshesInfoMesh.material;
-                        mesh = new Mesh(modelNode, meshCfg);
-                        childNode.addChild(mesh, false);
-                    }
-                    matrix = null;
-                    parent = childNode;
-                }
-
-                if (createEntity && numMeshes === 0 && hasChildNodes) {
-
-                    // Case 5: Creating explicit object, node has meshes OR node has child nodes
-
-                    let nodeCfg = {
-                        matrix: matrix
-                    };
-                    utils.apply(ctx.modelNodeProps, nodeCfg);
-                    utils.apply(createEntity, nodeCfg);
-                    createEntity.matrix = matrix;
-                    let childNode = new Node$1(modelNode, nodeCfg);
-                    parent.addChild(childNode, false); // Don't automatically inherit properties
-                    matrix = null;
-                    parent = childNode;
-                }
-
-                if (createEntity && numMeshes > 0 || hasChildNodes) {
-
-                    // Case 6: Creating explicit object, node has meshes OR node has child nodes
-
-                    let nodeCfg = {
-                        matrix: matrix
-                    };
-                    utils.apply(ctx.modelNodeProps, nodeCfg);
-                    if (createEntity) {
-                        utils.apply(createEntity, nodeCfg);
-                    }
-                    let childNode = new Node$1(modelNode, nodeCfg);
-                    parent.addChild(childNode, false); // Don't automatically inherit properties
-                    for (let i = 0, len = numMeshes; i < len; i++) {
-                        meshesInfoMesh = meshesInfo[i];
-                        let meshCfg = {
-                            geometry: meshesInfoMesh.geometry
-                        };
-                        utils.apply(ctx.modelProps, meshCfg);
-                        meshCfg.material = meshesInfoMesh.material;
-                        if (createEntity) {
-                            utils.apply(createEntity, meshCfg);
-                        }
-                        meshCfg.id = null; // Avoid ID clash with parent Node
-                        mesh = new Mesh(modelNode, meshCfg);
-                        childNode.addChild(mesh, false); // Don't automatically inherit properties
-                    }
-                    matrix = null;
-                    parent = childNode;
-                }
-            }
-        }
-
-        if (glTFNode.children) {
-            var children = glTFNode.children;
-            var childNodeInfo;
-            var childNodeIdx;
-            for (let i = 0, len = children.length; i < len; i++) {
-                childNodeIdx = children[i];
-                childNodeInfo = json.nodes[childNodeIdx];
-                if (!childNodeInfo) {
-                    error(ctx, "Node not found: " + i);
-                    continue;
-                }
-                loadNode(ctx, childNodeInfo, matrix, parent);
-            }
-        }
-    }
-
-    function error(ctx, msg) {
-        ctx.plugin.error(msg);
-    }
-})();
-
 function assert$5(condition, message) {
   if (!condition) {
     throw new Error(message || 'loader assertion failed.');
@@ -85271,7 +84471,7 @@ async function parse$1(arrayBuffer, options = {}, context) {
 /**
  * @private
  */
-class GLTFPerformanceModelLoader {
+class GLTFVBOSceneModelLoader {
 
     constructor(cfg) {
     }
@@ -85772,9 +84972,14 @@ const IFCObjectDefaults = {
 /**
  * {@link Viewer} plugin that loads models from [glTF](https://www.khronos.org/gltf/).
  *
+ * * Loads all glTF formats, including embedded and binary formats.
+ * * Loads physically-based materials and textures.
  * * Creates an {@link Entity} representing each model it loads, which will have {@link Entity#isModel} set ````true```` and will be registered by {@link Entity#id} in {@link Scene#models}.
  * * Creates an {@link Entity} for each object within the model, which is indicated by each glTF ````node```` that has a ````name```` attribute. Those Entities will have {@link Entity#isObject} set ````true```` and will be registered by {@link Entity#id} in {@link Scene#objects}.
  * * When loading, can set the World-space position, scale and rotation of each model within World space, along with initial properties for all the model's {@link Entity}s.
+ * * Not recommended for large models. For best performance with large glTF datasets, we recommend first converting them
+ * to ````.xkt```` format (eg. using [convert2xkt](https://github.com/xeokit/xeokit-convert)), then loading
+ * the ````.xkt```` using {@link XKTLoaderPlugin}.
  *
  * ## Metadata
  *
@@ -85785,23 +84990,6 @@ const IFCObjectDefaults = {
  * metadata, we can also provide GLTFLoaderPlugin with a custom lookup table of initial values to set on the properties of each type of {@link Entity}. By default, GLTFLoaderPlugin
  * uses its own map of default colors and visibilities for IFC element types.
  *
- * ## Quality Setting
- *
- * By default, GLTFLoaderPlugin will load a high-performance scene representation that's optimized for low memory usage and
- * optimal rendering. The high-performance representation renders large numbers of objects efficiently, using geometry
- * batching and instancing, with simple Lambertian shading that ignores any textures and realistic materials in the glTF.
- *
- * Specifying ````performance:false```` to {@link GLTFLoaderPlugin#load} will internally load a heavier scene
- * representation comprised of {@link Node}, {@link Mesh}, {@link Geometry}, {@link Material} and {@link Texture} components,
- * that will exactly preserve the materials specified in the glTF. Use this when you want to load a model for a realistic preview,
- * maybe using PBR etc.
- *
- * We tend to use the default ````performance:true```` setting for CAD and BIM models, where structure is more important that
- * surface appearance.
- *
- * Publically, GLTFLoaderPlugin creates the same {@link Entity}s for both levels of performance. Privately, however, it implements
- * {@link Entity}s using two different sets of concrete subtypes, for its two different internally-managed scene representations.
- *
  * ## Usage
  *
  * In the example below we'll load the Schependomlaan model from a [glTF file](http://xeokit.github.io/xeokit-sdk/examples/models/gltf/schependomlaan/), along
@@ -85815,8 +85003,6 @@ const IFCObjectDefaults = {
  *
  * Read more about this example in the user guide on [Viewing BIM Models Offline](https://www.notion.so/xeokit/Viewing-an-IFC-Model-with-xeokit-c373e48bc4094ff5b6e5c5700ff580ee).
  *
- * We're leaving ````performance: true```` since our model has many objects and we're not interested in realistic rendering.
- *
  * [[Run this example](http://xeokit.github.io/xeokit-sdk/examples/#BIMOffline_glTF_OTCConferenceCenter)]
  *
  * ````javascript
@@ -85855,8 +85041,7 @@ const IFCObjectDefaults = {
  *      id: "myModel",
  *      src: "./models/gltf/OTCConferenceCenter/scene.gltf",
  *      metaModelSrc: "./models/gltf/OTCConferenceCenter/metaModel.json",     // Creates a MetaModel (see below)
- *      edges: true,
- *      performance: true  // Load high-performance scene representation (default is false)
+ *      edges: true
  * });
  *
  * model.on("loaded", () => {
@@ -85958,16 +85143,8 @@ class GLTFLoaderPlugin extends Plugin {
     constructor(viewer, cfg = {}) {
 
         super("GLTFLoader", viewer, cfg);
-
-        /**
-         * @private
-         */
-        this._sceneGraphLoader = new GLTFSceneGraphLoader(this, cfg);
-
-        /**
-         * @private
-         */
-        this._performanceModelLoader = new GLTFPerformanceModelLoader(this, cfg);
+        
+        this._sceneModelLoader = new GLTFVBOSceneModelLoader(this, cfg);
 
         this.dataSource = cfg.dataSource;
         this.objectDefaults = cfg.objectDefaults;
@@ -86040,8 +85217,7 @@ class GLTFLoaderPlugin extends Plugin {
      * @param {Boolean} [params.colorTextureEnabled=true] Indicates if base color texture rendering is enabled for the model. Overridden by ````pbrEnabled````.  Only works when {@link Scene#colorTextureEnabled} is also ````true````.
      * @param {Boolean} [params.backfaces=false] When true, allows visible backfaces, wherever specified in the glTF. When false, ignores backfaces.
      * @param {Number} [params.edgeThreshold=10] When xraying, highlighting, selecting or edging, this is the threshold angle between normals of adjacent triangles, below which their shared wireframe edge is not drawn.
-     * @param {Boolean} [params.performance=true] Set ````false```` to load all the materials and textures provided by the glTF file, otherwise leave ````true```` to load the default high-performance representation optimized for low memory usage and efficient rendering.
-     * @returns {Entity} Entity representing the model, which will have {@link Entity#isModel} set ````true```` and will be registered by {@link Entity#id} in {@link Scene#models}
+      * @returns {Entity} Entity representing the model, which will have {@link Entity#isModel} set ````true```` and will be registered by {@link Entity#id} in {@link Scene#models}
      */
     load(params = {}) {
 
@@ -86050,20 +85226,7 @@ class GLTFLoaderPlugin extends Plugin {
             delete params.id;
         }
 
-        const performance = params.performance !== false;
-
-        const sceneModel = performance
-
-            // VBOSceneModel provides performance-oriented scene representation
-            // converting glTF materials to simple flat-shading without textures
-
-            ? new VBOSceneModel(this.viewer.scene, utils.apply(params, {
-                isModel: true
-            }))
-
-            // Scene Node graph supports original glTF materials
-
-            : new Node$1(this.viewer.scene, utils.apply(params, {
+        const sceneModel =  new VBOSceneModel(this.viewer.scene, utils.apply(params, {
                 isModel: true
             }));
 
@@ -86074,8 +85237,6 @@ class GLTFLoaderPlugin extends Plugin {
             return sceneModel; // Return new empty model
         }
 
-        const loader = performance ? this._performanceModelLoader : this._sceneGraphLoader;
-
         if (params.metaModelSrc || params.metaModelData) {
 
             const objectDefaults = params.objectDefaults || this._objectDefaults || IFCObjectDefaults;
@@ -86149,9 +85310,9 @@ class GLTFLoaderPlugin extends Plugin {
                 };
 
                 if (params.src) {
-                    loader.load(this, sceneModel, params.src, params);
+                    this._sceneModelLoader.load(this, sceneModel, params.src, params);
                 } else {
-                    loader.parse(this, sceneModel, params.gltf, params);
+                    this._sceneModelLoader.parse(this, sceneModel, params.gltf, params);
                 }
             };
 
@@ -86198,9 +85359,9 @@ class GLTFLoaderPlugin extends Plugin {
             };
 
             if (params.src) {
-                loader.load(this, sceneModel, params.src, params);
+                this._sceneModelLoader.load(this, sceneModel, params.src, params);
             } else {
-                loader.parse(this, sceneModel, params.gltf, params);
+                this._sceneModelLoader.parse(this, sceneModel, params.gltf, params);
             }
         }
 
@@ -89779,6 +88940,7 @@ const tempVec3$3 = math.vec3();
  * this example).
  * * Click a plane in the overview to activate a 3D control with which you can interactively
  * reposition its SectionPlane in the main canvas.
+ * * Use {@lin BCFViewpointsPlugin} to save and load SectionPlanes in BCF viewpoints.
  *
  * ## Usage
  *
@@ -89844,7 +89006,7 @@ const tempVec3$3 = math.vec3();
  * // Programmatically reposition one of our SectionPlanes
  * // This also updates its position as shown in the overview gizmo
  *
- * mySectionPlane2.pos = [11.0, 6.-, -12];
+ * mySectionPlane2.pos = [11.0, 6.0, -12];
  * mySectionPlane2.dir = [0.4, 0.0, 0.5];
  * ````
  */
@@ -156014,6 +155176,36 @@ class PerformanceModel extends VBOSceneModel {
     }
 }
 
+/**
+ * Transcodes texture data.
+ *
+ * A {@link SceneModel} configured with an appropriate TextureTranscoder will allow us to add textures from
+ * transcoded buffers or files. For a concrete example, see {@link VBOSceneModel}, which can be configured with
+ * a {@link KTX2TextureTranscoder}, which allows us to add textures from KTX2 buffers and files.
+ *
+ * @interface
+ */
+class TextureTranscoder {
+
+    /**
+     * Transcodes texture data from transcoded buffers into a {@link Texture2D}.
+     *
+     * @param {ArrayBuffer[]} buffers Transcoded texture data. Given as an array of buffers so that we can support
+     * multi-image textures, such as cube maps.
+     * @param {*} config Transcoding options.
+     * @param {Texture2D} texture The texture to load.
+     * @returns {Promise} Resolves when the texture has loaded.
+     */
+    transcode(buffers, texture, config = {}) {
+    }
+
+    /**
+     * Destroys this transcoder.
+     */
+    destroy() {
+    }
+}
+
 const screenPos = math.vec4();
 const viewPos = math.vec4();
 
@@ -156258,7 +155450,7 @@ class PivotController {
     /**
      * Returns true if we are currently pivoting.
      *
-     * @returns {boolean}
+     * @returns {Boolean}
      */
     getPivoting() {
         return this._pivoting;
@@ -156756,8 +155948,9 @@ class MousePanRotateDollyHandler {
             // Scaling drag-rotate to canvas boundary
 
             const canvasBoundary = scene.canvas.boundary;
-            const canvasWidth = canvasBoundary[2] - canvasBoundary[0];
-            const canvasHeight = canvasBoundary[3] - canvasBoundary[1];
+
+            const canvasWidth = canvasBoundary[2];
+            const canvasHeight = canvasBoundary[3];
             const x = states.pointerCanvasPos[0];
             const y = states.pointerCanvasPos[1];
 
@@ -158082,8 +157275,8 @@ class TouchPanRotateAndDollyHandler {
             // Scaling drag-rotate to canvas boundary
 
             const canvasBoundary = scene.canvas.boundary;
-            const canvasWidth = canvasBoundary[2] - canvasBoundary[0];
-            const canvasHeight = canvasBoundary[3] - canvasBoundary[1];
+            const canvasWidth = canvasBoundary[0];
+            const canvasHeight = canvasBoundary[1];
 
             const touches = event.touches;
 
@@ -161380,7 +160573,7 @@ class Configs {
      *
      * This should only be set once, before creating any Viewers.
      *
-     * @returns {boolean}
+     * @returns {Boolean}
      */
     set doublePrecisionEnabled(doublePrecision) {
         math.setDoublePrecisionEnabled(doublePrecision);
@@ -161389,7 +160582,7 @@ class Configs {
     /**
      * Gets whether double precision mode is enabled for all Viewers.
      *
-     * @returns {boolean}
+     * @returns {Boolean}
      */
     get doublePrecisionEnabled() {
         return math.getDoublePrecisionEnabled();
@@ -163613,9 +162806,11 @@ const tempVec3c = math.vec3();
  * ## Overview
  *
  * * Loads small-to-medium sized models directly from [CityJSON 1.0.0](https://www.cityjson.org/specs/1.0.0/) files.
- * * Not recommended for large models. For best performance with large CityJSON datasets, we recommend using {@link XKTLoaderPlugin}.
  * * Loads double-precision coordinates, enabling models to be viewed at global coordinates without accuracy loss.
  * * Allows to set the position, scale and rotation of each model as you load it.
+ * * Not recommended for large models. For best performance with large CityJSON datasets, we recommend
+ * converting them to ````.xkt```` format (eg. using [convert2xkt](https://github.com/xeokit/xeokit-convert)), then loading
+ * the ````.xkt```` using {@link XKTLoaderPlugin}.
  *
  * ## Limitations
  *