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

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();
@@ -45053,16 +45092,28 @@ const tempVec3c$6 = math.vec3();
  * 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.
  *
+ * ## Supported BCF Elements
+ *
+ * A BCF viewpoint saves and loads the following state into a xeokit {@link Viewer}:
+ *
+ * * {@link Camera} position, orientation and projection
+ * * {@link SectionPlane}s to slice the model
+ * * {@link LineSet}s to show 3D lines
+ * * {@link Bitmap}s to show images
+ * * {@link Entity} visibilities and selection states
+ *
  * ## 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)]
  *
  * ````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 +45121,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 +45150,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 +45197,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 +45291,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 +45400,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 +45413,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 +45734,9 @@ class BCFViewpointsPlugin extends Plugin {
             });
             new LineSet(scene, {
                 positions,
-                indices
+                indices,
+                clippable: false,
+                collidable: true
             });
         }
 
@@ -45696,6 +45749,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 +45775,10 @@ class BCFViewpointsPlugin extends Plugin {
                     type: bitmap_type,
                     pos: location,
                     normal: normal,
-                    up: up
+                    up: up,
+                    clippable: false,
+                    collidable: true,
+                    height
                 });
             });
         }
@@ -46360,7 +46417,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 +46438,7 @@ class DistanceMeasurement extends Component {
     /**
      * Gets whether this DistanceMeasurement is visible or not.
      *
-     * @type Boolean
+     * @type {Boolean}
      */
     get visible() {
         return this._visible;
@@ -46562,7 +46619,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 +54351,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 +63781,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 +67726,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 +72864,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,6 +73029,161 @@ class Loader {
     }
 }
 
+const loading = {};
+
+class FileLoader extends Loader {
+
+    constructor(manager) {
+        super(manager);
+    }
+
+    load(url, onLoad, onProgress, onError) {
+        if (url === undefined) {
+            url = '';
+        }
+        if (this.path !== undefined) {
+            url = this.path + url;
+        }
+        url = this.manager.resolveURL(url);
+        const cached = Cache.get(url);
+        if (cached !== undefined) {
+            this.manager.itemStart(url);
+            setTimeout(() => {
+                if (onLoad) {
+                    onLoad(cached);
+                }
+                this.manager.itemEnd(url);
+            }, 0);
+            return cached;
+        }
+        if (loading[url] !== undefined) {
+            loading[url].push({onLoad, onProgress, onError});
+            return;
+        }
+        loading[url] = [];
+        loading[url].push({onLoad, onProgress, onError});
+        const req = new Request(url, {
+            headers: new Headers(this.requestHeader),
+            credentials: this.withCredentials ? 'include' : 'same-origin'
+        });
+        const mimeType = this.mimeType;
+        const responseType = this.responseType;
+        fetch(req).then(response => {
+            if (response.status === 200 || response.status === 0) {
+                // Some browsers return HTTP Status 0 when using non-http protocol
+                // e.g. 'file://' or 'data://'. Handle as success.
+                if (response.status === 0) {
+                    console.warn('FileLoader: HTTP Status 0 received.');
+                }
+                if (typeof ReadableStream === 'undefined' || response.body.getReader === undefined) {
+                    return response;
+                }
+                const callbacks = loading[url];
+                const reader = response.body.getReader();
+                const contentLength = response.headers.get('Content-Length');
+                const total = contentLength ? parseInt(contentLength) : 0;
+                const lengthComputable = total !== 0;
+                let loaded = 0;
+                const stream = new ReadableStream({
+                    start(controller) {
+                        readData();
+
+                        function readData() {
+                            reader.read().then(({done, value}) => {
+                                if (done) {
+                                    controller.close();
+                                } else {
+                                    loaded += value.byteLength;
+                                    const event = new ProgressEvent('progress', {lengthComputable, loaded, total});
+                                    for (let i = 0, il = callbacks.length; i < il; i++) {
+                                        const callback = callbacks[i];
+                                        if (callback.onProgress) {
+                                            callback.onProgress(event);
+                                        }
+                                    }
+                                    controller.enqueue(value);
+                                    readData();
+                                }
+                            });
+                        }
+                    }
+                });
+                return new Response(stream);
+            } else {
+                throw Error(`fetch for "${response.url}" responded with ${response.status}: ${response.statusText}`);
+            }
+        }).then(response => {
+            switch (responseType) {
+                case 'arraybuffer':
+                    return response.arrayBuffer();
+                case 'blob':
+                    return response.blob();
+                case 'document':
+                    return response.text()
+                        .then(text => {
+                            const parser = new DOMParser();
+                            return parser.parseFromString(text, mimeType);
+                        });
+                case 'json':
+                    return response.json();
+                default:
+                    if (mimeType === undefined) {
+                        return response.text();
+                    } else {
+                        // sniff encoding
+                        const re = /charset="?([^;"\s]*)"?/i;
+                        const exec = re.exec(mimeType);
+                        const label = exec && exec[1] ? exec[1].toLowerCase() : undefined;
+                        const decoder = new TextDecoder(label);
+                        return response.arrayBuffer().then(ab => decoder.decode(ab));
+                    }
+            }
+        }).then(data => {
+            // Add to cache only on HTTP success, so that we do not cache
+            // error response bodies as proper responses to requests.
+            Cache.add(url, data);
+            const callbacks = loading[url];
+            delete loading[url];
+            for (let i = 0, il = callbacks.length; i < il; i++) {
+                const callback = callbacks[i];
+                if (callback.onLoad) {
+                    callback.onLoad(data);
+                }
+            }
+        }).catch(err => {
+            // Abort errors and other errors are handled the same
+            const callbacks = loading[url];
+            if (callbacks === undefined) {
+                // When onLoad was called and url was deleted in `loading`
+                this.manager.itemError(url);
+                throw err;
+
+            }
+            delete loading[url];
+            for (let i = 0, il = callbacks.length; i < il; i++) {
+                const callback = callbacks[i];
+                if (callback.onError) {
+                    callback.onError(err);
+                }
+            }
+            this.manager.itemError(url);
+        }).finally(() => {
+            this.manager.itemEnd(url);
+        });
+        this.manager.itemStart(url);
+    }
+
+    setResponseType(value) {
+        this.responseType = value;
+        return this;
+    }
+
+    setMimeType(value) {
+        this.mimeType = value;
+        return this;
+    }
+}
+
 /**
  * @author Deepkolos / https://github.com/deepkolos
  */
@@ -73018,219 +73258,6 @@ class WorkerPool$1 {
 
 }
 
-/**
- * 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 {
-
-    constructor(manager) {
-        super(manager);
-    }
-
-    load(url, onLoad, onProgress, onError) {
-        if (url === undefined) {
-            url = '';
-        }
-        if (this.path !== undefined) {
-            url = this.path + url;
-        }
-        url = this.manager.resolveURL(url);
-        const cached = Cache.get(url);
-        if (cached !== undefined) {
-            this.manager.itemStart(url);
-            setTimeout(() => {
-                if (onLoad) {
-                    onLoad(cached);
-                }
-                this.manager.itemEnd(url);
-            }, 0);
-            return cached;
-        }
-        if (loading[url] !== undefined) {
-            loading[url].push({onLoad, onProgress, onError});
-            return;
-        }
-        loading[url] = [];
-        loading[url].push({onLoad, onProgress, onError});
-        const req = new Request(url, {
-            headers: new Headers(this.requestHeader),
-            credentials: this.withCredentials ? 'include' : 'same-origin'
-        });
-        const mimeType = this.mimeType;
-        const responseType = this.responseType;
-        fetch(req).then(response => {
-            if (response.status === 200 || response.status === 0) {
-                // Some browsers return HTTP Status 0 when using non-http protocol
-                // e.g. 'file://' or 'data://'. Handle as success.
-                if (response.status === 0) {
-                    console.warn('FileLoader: HTTP Status 0 received.');
-                }
-                if (typeof ReadableStream === 'undefined' || response.body.getReader === undefined) {
-                    return response;
-                }
-                const callbacks = loading[url];
-                const reader = response.body.getReader();
-                const contentLength = response.headers.get('Content-Length');
-                const total = contentLength ? parseInt(contentLength) : 0;
-                const lengthComputable = total !== 0;
-                let loaded = 0;
-                const stream = new ReadableStream({
-                    start(controller) {
-                        readData();
-
-                        function readData() {
-                            reader.read().then(({done, value}) => {
-                                if (done) {
-                                    controller.close();
-                                } else {
-                                    loaded += value.byteLength;
-                                    const event = new ProgressEvent('progress', {lengthComputable, loaded, total});
-                                    for (let i = 0, il = callbacks.length; i < il; i++) {
-                                        const callback = callbacks[i];
-                                        if (callback.onProgress) {
-                                            callback.onProgress(event);
-                                        }
-                                    }
-                                    controller.enqueue(value);
-                                    readData();
-                                }
-                            });
-                        }
-                    }
-                });
-                return new Response(stream);
-            } else {
-                throw Error(`fetch for "${response.url}" responded with ${response.status}: ${response.statusText}`);
-            }
-        }).then(response => {
-            switch (responseType) {
-                case 'arraybuffer':
-                    return response.arrayBuffer();
-                case 'blob':
-                    return response.blob();
-                case 'document':
-                    return response.text()
-                        .then(text => {
-                            const parser = new DOMParser();
-                            return parser.parseFromString(text, mimeType);
-                        });
-                case 'json':
-                    return response.json();
-                default:
-                    if (mimeType === undefined) {
-                        return response.text();
-                    } else {
-                        // sniff encoding
-                        const re = /charset="?([^;"\s]*)"?/i;
-                        const exec = re.exec(mimeType);
-                        const label = exec && exec[1] ? exec[1].toLowerCase() : undefined;
-                        const decoder = new TextDecoder(label);
-                        return response.arrayBuffer().then(ab => decoder.decode(ab));
-                    }
-            }
-        }).then(data => {
-            // Add to cache only on HTTP success, so that we do not cache
-            // error response bodies as proper responses to requests.
-            Cache.add(url, data);
-            const callbacks = loading[url];
-            delete loading[url];
-            for (let i = 0, il = callbacks.length; i < il; i++) {
-                const callback = callbacks[i];
-                if (callback.onLoad) {
-                    callback.onLoad(data);
-                }
-            }
-        }).catch(err => {
-            // Abort errors and other errors are handled the same
-            const callbacks = loading[url];
-            if (callbacks === undefined) {
-                // When onLoad was called and url was deleted in `loading`
-                this.manager.itemError(url);
-                throw err;
-
-            }
-            delete loading[url];
-            for (let i = 0, il = callbacks.length; i < il; i++) {
-                const callback = callbacks[i];
-                if (callback.onError) {
-                    callback.onError(err);
-                }
-            }
-            this.manager.itemError(url);
-        }).finally(() => {
-            this.manager.itemEnd(url);
-        });
-        this.manager.itemStart(url);
-    }
-
-    setResponseType(value) {
-        this.responseType = value;
-        return this;
-    }
-
-    setMimeType(value) {
-        this.mimeType = value;
-        return this;
-    }
-}
-
 const KTX2TransferSRGB = 2;
 const KTX2_ALPHA_PREMULTIPLIED = 1;
 
@@ -77114,848 +77141,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 +84456,7 @@ async function parse$1(arrayBuffer, options = {}, context) {
 /**
  * @private
  */
-class GLTFPerformanceModelLoader {
+class GLTFVBOSceneModelLoader {
 
     constructor(cfg) {
     }
@@ -85772,9 +84957,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 +84975,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 +84988,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 +85026,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 +85128,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 +85202,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 +85211,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 +85222,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 +85295,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 +85344,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 +88925,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 +88991,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 +155161,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 +155435,7 @@ class PivotController {
     /**
      * Returns true if we are currently pivoting.
      *
-     * @returns {boolean}
+     * @returns {Boolean}
      */
     getPivoting() {
         return this._pivoting;
@@ -161380,7 +160557,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 +160566,7 @@ class Configs {
     /**
      * Gets whether double precision mode is enabled for all Viewers.
      *
-     * @returns {boolean}
+     * @returns {Boolean}
      */
     get doublePrecisionEnabled() {
         return math.getDoublePrecisionEnabled();
@@ -163613,9 +162790,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
  *