@xeokit/xeokit-sdk 2.6.31 → 2.6.33

package/src/viewer/scene/webgl/Renderer.js

@@ -32,6 +32,9 @@ const Renderer = function (scene, options) {
     let drawableTypeInfo = {};
     let drawables = {};
 
+    let postSortDrawableList = [];
+    let postCullDrawableList = [];
+
     let drawableListDirty = true;
     let stateSortDirty = true;
     let imageDirty = true;
@@ -264,33 +267,33 @@ const Renderer = function (scene, options) {
     }
 
     function sortDrawableList() {
+        let lenDrawableList = 0;
         for (let type in drawableTypeInfo) {
             if (drawableTypeInfo.hasOwnProperty(type)) {
                 const drawableInfo = drawableTypeInfo[type];
-                if (drawableInfo.isStateSortable) {
-                    drawableInfo.drawableListPreCull.sort(drawableInfo.stateSortCompare);
+                const drawableListPreCull = drawableInfo.drawableListPreCull;
+                for (let i = 0, len = drawableListPreCull.length; i < len; i++) {
+                    const drawable = drawableListPreCull[i];
+                    postSortDrawableList[lenDrawableList++] = drawable;
                 }
             }
         }
+        postSortDrawableList.length = lenDrawableList;
+        postSortDrawableList.sort((a, b) => {
+            return a.renderOrder - b.renderOrder;
+        });
     }
 
     function cullDrawableList() {
-        for (let type in drawableTypeInfo) {
-            if (drawableTypeInfo.hasOwnProperty(type)) {
-                const drawableInfo = drawableTypeInfo[type];
-                const drawableListPreCull = drawableInfo.drawableListPreCull;
-                const drawableList = drawableInfo.drawableList;
-                let lenDrawableList = 0;
-                for (let i = 0, len = drawableListPreCull.length; i < len; i++) {
-                    const drawable = drawableListPreCull[i];
-                    drawable.rebuildRenderFlags();
-                    if (!drawable.renderFlags.culled) {
-                        drawableList[lenDrawableList++] = drawable;
-                    }
-                }
-                drawableList.length = lenDrawableList;
+        let lenDrawableList = 0;
+        for (let i = 0, len = postSortDrawableList.length; i < len; i++) {
+            const drawable = postSortDrawableList[i];
+            drawable.rebuildRenderFlags();
+            if (!drawable.renderFlags.culled) {
+                postCullDrawableList[lenDrawableList++] = drawable;
             }
         }
+        postCullDrawableList.length = lenDrawableList;
     }
 
     function draw(params) {
@@ -366,25 +369,16 @@ const Renderer = function (scene, options) {
         if (params.clear !== false) {
             gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
         }
+        for (let i = 0, len = postCullDrawableList.length; i < len; i++) {
 
-        for (let type in drawableTypeInfo) {
-            if (drawableTypeInfo.hasOwnProperty(type)) {
-
-                const drawableInfo = drawableTypeInfo[type];
-                const drawableList = drawableInfo.drawableList;
-
-                for (let i = 0, len = drawableList.length; i < len; i++) {
-
-                    const drawable = drawableList[i];
+            const drawable = postCullDrawableList[i];
 
-                    if (drawable.culled === true || drawable.visible === false || !drawable.drawDepth || !drawable.saoEnabled) {
-                        continue;
-                    }
+            if (drawable.culled === true || drawable.visible === false || !drawable.drawDepth || !drawable.saoEnabled) {
+                continue;
+            }
 
-                    if (drawable.renderFlags.colorOpaque) {
-                        drawable.drawDepth(frameCtx);
-                    }
-                }
+            if (drawable.renderFlags.colorOpaque) {
+                drawable.drawDepth(frameCtx);
             }
         }
 
@@ -567,93 +561,85 @@ const Renderer = function (scene, options) {
         // Render normal opaque solids, defer others to bins to render after
         //------------------------------------------------------------------------------------------------------
 
-        for (let type in drawableTypeInfo) {
-            if (drawableTypeInfo.hasOwnProperty(type)) {
-
-                const drawableInfo = drawableTypeInfo[type];
-                const drawableList = drawableInfo.drawableList;
-
-                for (i = 0, len = drawableList.length; i < len; i++) {
+        for (let i = 0, len = postCullDrawableList.length; i < len; i++) {
 
-                    drawable = drawableList[i];
+            drawable = postCullDrawableList[i];
 
-                    if (drawable.culled === true || drawable.visible === false) {
-                        continue;
-                    }
+            if (drawable.culled === true || drawable.visible === false) {
+                continue;
+            }
 
-                    const renderFlags = drawable.renderFlags;
+            const renderFlags = drawable.renderFlags;
 
-                    if (renderFlags.colorOpaque) {
-                        if (saoEnabled && saoPossible && drawable.saoEnabled) {
-                            normalDrawSAOBin[normalDrawSAOBinLen++] = drawable;
-                        } else {
-                            drawable.drawColorOpaque(frameCtx);
-                        }
-                    }
+            if (renderFlags.colorOpaque) {
+                if (saoEnabled && saoPossible && drawable.saoEnabled) {
+                    normalDrawSAOBin[normalDrawSAOBinLen++] = drawable;
+                } else {
+                    drawable.drawColorOpaque(frameCtx);
+                }
+            }
 
-                    if (transparentEnabled) {
-                        if (renderFlags.colorTransparent) {
-                            normalFillTransparentBin[normalFillTransparentBinLen++] = drawable;
-                        }
-                    }
+            if (transparentEnabled) {
+                if (renderFlags.colorTransparent) {
+                    normalFillTransparentBin[normalFillTransparentBinLen++] = drawable;
+                }
+            }
 
-                    if (renderFlags.xrayedSilhouetteTransparent) {
-                        xrayedFillTransparentBin[xrayedFillTransparentBinLen++] = drawable;
-                    }
+            if (renderFlags.xrayedSilhouetteTransparent) {
+                xrayedFillTransparentBin[xrayedFillTransparentBinLen++] = drawable;
+            }
 
-                    if (renderFlags.xrayedSilhouetteOpaque) {
-                        xrayedFillOpaqueBin[xrayedFillOpaqueBinLen++] = drawable;
-                    }
+            if (renderFlags.xrayedSilhouetteOpaque) {
+                xrayedFillOpaqueBin[xrayedFillOpaqueBinLen++] = drawable;
+            }
 
-                    if (renderFlags.highlightedSilhouetteTransparent) {
-                        highlightedFillTransparentBin[highlightedFillTransparentBinLen++] = drawable;
-                    }
+            if (renderFlags.highlightedSilhouetteTransparent) {
+                highlightedFillTransparentBin[highlightedFillTransparentBinLen++] = drawable;
+            }
 
-                    if (renderFlags.highlightedSilhouetteOpaque) {
-                        highlightedFillOpaqueBin[highlightedFillOpaqueBinLen++] = drawable;
-                    }
+            if (renderFlags.highlightedSilhouetteOpaque) {
+                highlightedFillOpaqueBin[highlightedFillOpaqueBinLen++] = drawable;
+            }
 
-                    if (renderFlags.selectedSilhouetteTransparent) {
-                        selectedFillTransparentBin[selectedFillTransparentBinLen++] = drawable;
-                    }
+            if (renderFlags.selectedSilhouetteTransparent) {
+                selectedFillTransparentBin[selectedFillTransparentBinLen++] = drawable;
+            }
 
-                    if (renderFlags.selectedSilhouetteOpaque) {
-                        selectedFillOpaqueBin[selectedFillOpaqueBinLen++] = drawable;
-                    }
+            if (renderFlags.selectedSilhouetteOpaque) {
+                selectedFillOpaqueBin[selectedFillOpaqueBinLen++] = drawable;
+            }
 
-                    if (drawable.edges && edgesEnabled) {
-                        if (renderFlags.edgesOpaque) {
-                            normalEdgesOpaqueBin[normalEdgesOpaqueBinLen++] = drawable;
-                        }
+            if (drawable.edges && edgesEnabled) {
+                if (renderFlags.edgesOpaque) {
+                    normalEdgesOpaqueBin[normalEdgesOpaqueBinLen++] = drawable;
+                }
 
-                        if (renderFlags.edgesTransparent) {
-                            normalEdgesTransparentBin[normalEdgesTransparentBinLen++] = drawable;
-                        }
+                if (renderFlags.edgesTransparent) {
+                    normalEdgesTransparentBin[normalEdgesTransparentBinLen++] = drawable;
+                }
 
-                        if (renderFlags.selectedEdgesTransparent) {
-                            selectedEdgesTransparentBin[selectedEdgesTransparentBinLen++] = drawable;
-                        }
+                if (renderFlags.selectedEdgesTransparent) {
+                    selectedEdgesTransparentBin[selectedEdgesTransparentBinLen++] = drawable;
+                }
 
-                        if (renderFlags.selectedEdgesOpaque) {
-                            selectedEdgesOpaqueBin[selectedEdgesOpaqueBinLen++] = drawable;
-                        }
+                if (renderFlags.selectedEdgesOpaque) {
+                    selectedEdgesOpaqueBin[selectedEdgesOpaqueBinLen++] = drawable;
+                }
 
-                        if (renderFlags.xrayedEdgesTransparent) {
-                            xrayEdgesTransparentBin[xrayEdgesTransparentBinLen++] = drawable;
-                        }
+                if (renderFlags.xrayedEdgesTransparent) {
+                    xrayEdgesTransparentBin[xrayEdgesTransparentBinLen++] = drawable;
+                }
 
-                        if (renderFlags.xrayedEdgesOpaque) {
-                            xrayEdgesOpaqueBin[xrayEdgesOpaqueBinLen++] = drawable;
-                        }
+                if (renderFlags.xrayedEdgesOpaque) {
+                    xrayEdgesOpaqueBin[xrayEdgesOpaqueBinLen++] = drawable;
+                }
 
-                        if (renderFlags.highlightedEdgesTransparent) {
-                            highlightedEdgesTransparentBin[highlightedEdgesTransparentBinLen++] = drawable;
-                        }
+                if (renderFlags.highlightedEdgesTransparent) {
+                    highlightedEdgesTransparentBin[highlightedEdgesTransparentBinLen++] = drawable;
+                }
 
-                        if (renderFlags.highlightedEdgesOpaque) {
-                            highlightedEdgesOpaqueBin[highlightedEdgesOpaqueBinLen++] = drawable;
-                        }
-                    }
+                if (renderFlags.highlightedEdgesOpaque) {
+                    highlightedEdgesOpaqueBin[highlightedEdgesOpaqueBinLen++] = drawable;
                 }
             }
         }
@@ -1063,7 +1049,7 @@ const Renderer = function (scene, options) {
         frameCtx.pickInvisible = !!params.pickInvisible;
         frameCtx.pickClipPos = [
             getClipPosX(canvasPos[0] * resolutionScale, gl.drawingBufferWidth),
-            getClipPosY(canvasPos[1] * resolutionScale, gl.drawingBufferHeight),
+            getClipPosY(canvasPos[1] * resolutionScale, gl.drawingBufferHeight)
         ];
 
         gl.viewport(0, 0, 1, 1);
@@ -1076,30 +1062,23 @@ const Renderer = function (scene, options) {
         const includeEntityIds = params.includeEntityIds;
         const excludeEntityIds = params.excludeEntityIds;
 
-        for (let type in drawableTypeInfo) {
-            if (drawableTypeInfo.hasOwnProperty(type)) {
-
-                const drawableInfo = drawableTypeInfo[type];
-                const drawableList = drawableInfo.drawableList;
-
-                for (let i = 0, len = drawableList.length; i < len; i++) {
-
-                    const drawable = drawableList[i];
-
-                    if (!drawable.drawPickMesh || (params.pickInvisible !== true && drawable.visible === false) || drawable.pickable === false) {
-                        continue;
-                    }
-                    if (includeEntityIds && !includeEntityIds[drawable.id]) { // TODO: push this logic into drawable
-                        continue;
-                    }
-                    if (excludeEntityIds && excludeEntityIds[drawable.id]) {
-                        continue;
-                    }
-
-                    drawable.drawPickMesh(frameCtx);
-                }
+        for (let i = 0, len = postCullDrawableList.length; i < len; i++) {
+            const drawable = postCullDrawableList[i];
+            if (drawable.culled === true || drawable.visible === false) {
+                continue;
+            }
+            if (!drawable.drawPickMesh || (params.pickInvisible !== true && drawable.visible === false) || drawable.pickable === false) {
+                continue;
+            }
+            if (includeEntityIds && !includeEntityIds[drawable.id]) { // TODO: push this logic into drawable
+                continue;
             }
+            if (excludeEntityIds && excludeEntityIds[drawable.id]) {
+                continue;
+            }
+            drawable.drawPickMesh(frameCtx);
         }
+
         const pix = pickBuffer.read(0, 0);
         const pickID = pix[0] + (pix[1] << 8) + (pix[2] << 16) + (pix[3] << 24);
 
@@ -1129,7 +1108,7 @@ const Renderer = function (scene, options) {
         // frameCtx.pickInvisible = !!params.pickInvisible;
         frameCtx.pickClipPos = [
             getClipPosX(canvasPos[0] * resolutionScale, gl.drawingBufferWidth),
-            getClipPosY(canvasPos[1] * resolutionScale, gl.drawingBufferHeight),
+            getClipPosY(canvasPos[1] * resolutionScale, gl.drawingBufferHeight)
         ];
 
         gl.viewport(0, 0, 1, 1);
@@ -1178,7 +1157,7 @@ const Renderer = function (scene, options) {
             frameCtx.pickElementsOffset = pickable.pickElementsOffset;
             frameCtx.pickClipPos = [
                 getClipPosX(canvasPos[0] * resolutionScale, gl.drawingBufferWidth),
-                getClipPosY(canvasPos[1] * resolutionScale, gl.drawingBufferHeight),
+                getClipPosY(canvasPos[1] * resolutionScale, gl.drawingBufferHeight)
             ];
 
             gl.viewport(0, 0, 1, 1);
@@ -1243,15 +1222,14 @@ const Renderer = function (scene, options) {
     function drawSnapInit(frameCtx) {
         frameCtx.snapPickLayerParams = [];
         frameCtx.snapPickLayerNumber = 0;
-        for (let type in drawableTypeInfo) {
-            const drawableInfo = drawableTypeInfo[type];
-            const drawableList = drawableInfo.drawableList;
-            for (let i = 0, len = drawableList.length; i < len; i++) {
-                const drawable = drawableList[i];
-                if (drawable.drawSnapInit) {
-                    if (!drawable.culled && drawable.visible && drawable.pickable) {
-                        drawable.drawSnapInit(frameCtx);
-                    }
+
+        for (let i = 0, len = postCullDrawableList.length; i < len; i++) {
+
+            const drawable = postCullDrawableList[i];
+
+            if (drawable.drawSnapInit) {
+                if (!drawable.culled && drawable.visible && drawable.pickable) {
+                    drawable.drawSnapInit(frameCtx);
                 }
             }
         }
@@ -1261,11 +1239,11 @@ const Renderer = function (scene, options) {
     function drawSnap(frameCtx) {
         frameCtx.snapPickLayerParams = frameCtx.snapPickLayerParams || [];
         frameCtx.snapPickLayerNumber = frameCtx.snapPickLayerParams.length;
-        for (let type in drawableTypeInfo) {
-            const drawableInfo = drawableTypeInfo[type];
-            const drawableList = drawableInfo.drawableList;
-            for (let i = 0, len = drawableList.length; i < len; i++) {
-                const drawable = drawableList[i];
+        for (let i = 0, len = postCullDrawableList.length; i < len; i++) {
+
+            const drawable = postCullDrawableList[i];
+
+            if (drawable.drawSnapInit) {
                 if (drawable.drawSnap) {
                     if (!drawable.culled && drawable.visible && drawable.pickable) {
                         drawable.drawSnap(frameCtx);
@@ -1655,19 +1633,16 @@ const Renderer = function (scene, options) {
             gl.disable(gl.BLEND);
             gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
 
-            for (let type in drawableTypeInfo) {
-                if (drawableTypeInfo.hasOwnProperty(type)) {
-                    const drawableInfo = drawableTypeInfo[type];
-                    const drawableList = drawableInfo.drawableList;
-                    for (let i = 0, len = drawableList.length; i < len; i++) {
-                        const drawable = drawableList[i];
-                        if (!drawable.drawOcclusion || drawable.culled === true || drawable.visible === false || drawable.pickable === false) { // TODO: Option to exclude transparent?
-                            continue;
-                        }
 
-                        drawable.drawOcclusion(frameCtx);
-                    }
+            for (let i = 0, len = postCullDrawableList.length; i < len; i++) {
+
+                const drawable = postCullDrawableList[i];
+
+                if (!drawable.drawOcclusion || drawable.culled === true || drawable.visible === false || drawable.pickable === false) { // TODO: Option to exclude transparent?
+                    continue;
                 }
+
+                drawable.drawOcclusion(frameCtx);
             }
 
             this._occlusionTester.drawMarkers(frameCtx);
@@ -1794,4 +1769,4 @@ const Renderer = function (scene, options) {
     };
 };
 
-export {Renderer};
+export {Renderer};

package/types/extras/ContextMenu/ContextMenu.d.ts

@@ -7,6 +7,8 @@ export declare type ContextMenuConfiguration = {
   enabled?: boolean;
   /** Whether this ````ContextMenu```` automatically hides whenever we mouse-down or tap anywhere in the page. */
   hideOnMouseDown?: boolean;
+  /** Whether this ````ContextMenu```` automatically hides whenever we call its action. */
+  hideOnAction?: boolean;
 };
 
 /**

package/types/extras/PointerLens/PointerLens.d.ts

@@ -47,6 +47,11 @@ export class PointerLens {
     constructor(viewer: Viewer, cfg?: {
         active?: boolean;
         zoomFactor?: number;
+        containerId?: string;
+        lensPosToggle?: boolean,
+        lensPosToggleAmount?: number,
+        lensPosMarginLeft?: number,
+        lensPosMarginTop?: number;
     });
 
     /**
@@ -137,6 +142,48 @@ export class PointerLens {
      */
     get visible(): boolean;
 
+    /**
+     * Sets whether the pointer lens container should toggle position when mouse is over it.
+     *
+     * @param {boolean} lensPosToggle Whether we should toggle position.
+     */
+    set lensPosToggle(lensPosToggle: boolean);
+
+    /**
+     * Gets whether we should toggle position.
+     *
+     * @returns {boolean} Whether we should toggle position.
+     */
+    get lensPosToggle(): boolean;
+
+    /**
+     * Sets whether we toggle position in vertical or horizontal.
+     *
+     * @param {boolean} lensPosToggleVertical Vertical or horizontal change.
+     */
+    set lensPosToggleVertical(lensPosToggleVertical: boolean);
+
+    /**
+     * Gets whether we toggle position in vertical or horizontal.
+     *
+     * @returns {boolean} Vertical or horizontal change.
+     */
+    get lensPosToggleVertical(): boolean;
+
+    /**
+     * Sets amount of pixels we toggle position.
+     *
+     * @param {number} lensPosToggleAmount Amount of pixels we toggle position.
+     */
+    set lensPosToggleAmount(lensPosToggleAmount: number);
+
+    /**
+     * Gets amount of pixels we toggle position.
+     *
+     * @returns {number} Amount of pixels we toggle position.
+     */
+    get lensPosToggleAmount(): number;
+
     /**
      * Destroys this PointerLens.
      */

package/types/plugins/DistanceMeasurementsPlugin/DistanceMeasurement.d.ts

@@ -12,6 +12,24 @@ export declare class DistanceMeasurement extends Component {
    */
   plugin: DistanceMeasurementsPlugin;
 
+  /**
+   * Sets the axes basis for the measurement.
+   * 
+   * The value is a 4x4 matrix where each column-vector defines an axis and must have unit length.
+   * 
+   * This is the ```identity``` matrix by default, meaning the measurement axes are the same as the world axes.
+   */
+  set axesBasis(value: number[]);
+
+  /**
+   * Gets the axes basis for the measurement.
+   * 
+   * The value is a 4x4 matrix where each column-vector defines an axis and must have unit length.
+   * 
+   * This is the ```identity``` matrix by default, meaning the measurement axes are the same as the world axes.
+   */
+  get axesBasis(): number[];
+
   /**
    * Sets whether this DistanceMeasurement indicates that its measurement is approximate.
    *

package/types/plugins/DistanceMeasurementsPlugin/DistanceMeasurementsPlugin.d.ts

@@ -200,6 +200,18 @@ export declare class DistanceMeasurementsPlugin extends Plugin {
       labelsOnWires?: boolean;
   }): DistanceMeasurement;
   
+  /**
+   * Gets whether the distance measurement axis are visible.
+   * @returns {Boolean}
+   */
+  getAxisVisible(): boolean;
+
+  /**
+   * Sets whether the distance measurement axis are visible.
+   * @param {Boolean} axisVisible
+   */
+  setAxisVisible(axisVisible: boolean): void;
+
   /**
    * Destroys a {@link DistanceMeasurement}.
    *

package/types/plugins/LASLoaderPlugin/LASLoaderPlugin.d.ts

@@ -32,6 +32,10 @@ export declare type LoadLASModel = {
   src?: string;
   /** The LAS file data, as an alternative to the ````src```` parameter. */
   las?: ArrayBuffer;
+  /** Create entity with this id */
+  entityId?: string;
+  /** Creates a MetaModel from json */
+  metaModelJSON?: any;
   /** Whether to load metadata for the LAS model. */
   loadMetadata?: boolean;
   /** The model's World-space double-precision 3D origin. Use this to position the model within xeokit's World coordinate system, using double-precision coordinates. */

package/types/plugins/NavCubePlugin/NavCubePlugin.d.ts

@@ -13,11 +13,11 @@ export declare type NavCubePluginConfiguration = {
   /** Whether the shadow of the cube is visible. */
   shadowVisible?: boolean;
   /** Whether the {@link Camera} flies or jumps to each selected axis or diagonal. */
-  cameraFly?: string;
+  cameraFly?: boolean;
   /** How much of the field-of-view, in degrees, that the 3D scene should fill the {@link Canvas} when the {@link Camera} moves to an axis or diagonal. */
-  cameraFitFOV?: string;
+  cameraFitFOV?: number;
   /** When flying the {@link Camera} to each new axis or diagonal, how long, in seconds, that the Camera takes to get there. */
-  cameraFlyDuration?: string;
+  cameraFlyDuration?: number;
   /** Custom uniform color for the faces of the NavCube. */
   color?: string;
   /** Custom color for the front face of the NavCube. Overrides ````color````. */
@@ -131,18 +131,18 @@ export declare class NavCubePlugin extends Plugin {
      *
      * Default is ````0.5````.
      *
-     * @param {Boolean} value Camera flight duration in seconds.
+     * @param {Number} value Camera flight duration in seconds.
      */
-    setCameraFlyDuration(value: boolean): void;
+    setCameraFlyDuration(value: number): void;
 
     /**
      * When flying the {@link Camera} to each new axis or diagonal, gets how long, in seconds, that the Camera takes to get there.
      *
      * Default is ````0.5````.
      *
-     * @returns {Boolean} Camera flight duration in seconds.
+     * @returns {Number} Camera flight duration in seconds.
      */
-    getCameraFlyDuration(): boolean;
+    getCameraFlyDuration(): number;
 
     /**
      * Sets whether the NavCube switches between perspective and orthographic projections in synchrony with

package/types/plugins/StoreyViewsPlugin/StoreyViewsPlugin.d.ts

@@ -6,6 +6,8 @@ import { StoreyMap } from "./StoreyMap";
 export declare type StoreyViewsPluginConfiguration = {
   /** Optional ID for this plugin, so that we can find it within {@link Viewer.plugins}. */
   id?: string;
+  /** Optional configuration, if enabled, the elements of each floor map image will be proportionally resized to encompass the entire image. This leads to varying scales among different floor map images. If disabled, each floor map image will display the model's extents, ensuring a consistent scale across all images */
+  fitStoreyMaps? : Boolean;
 };
 
 /**
@@ -116,6 +118,23 @@ export declare class StoreyViewsPlugin extends Plugin {
     */
   getStoreyContainingWorldPos(worldPos: number[]): string;
 
+  /**
+   * Gets the ID of the storey which's bounding box contains the y point of the world position
+   * 
+   * @param {Number[]} worldPos 3D World-space position.
+   * @returns {String} ID of the storey containing the position, or null if the position falls outside all the storeys.
+   */
+  getStoreyInVerticalRange(worldPos: number[]): string;
+
+
+  /**
+   * Gets the ID of the storey that contains the given 3D World-space position.
+   *.
+    * @param {Number[]} worldPos 3D World-space position.
+    * @returns {String} ID of the storey containing the position, or null if the position falls outside all the storeys.
+    */
+  isPositionAboveOrBelowBuilding(worldPos: number[]): string;
+
   /**
    * Converts a 3D World-space position to a 2D position within a StoreyMap image.
    *

package/types/viewer/scene/scene/Scene.d.ts

@@ -10,6 +10,7 @@ import { VBOSceneModel } from "../models/VBOSceneModel/VBOSceneModel";
 import { Mesh } from "../mesh";
 import { Node } from "../nodes";
 import { Input } from "../input/input";
+import { SectionPlane } from "../sectionPlane/SectionPlane";
 
 export declare type TickEvent = {
   /** The ID of this Scene. */
@@ -74,6 +75,20 @@ export declare class Scene extends Component {
    */
    on(event: "tick", callback: (tickEvent: TickEvent) => void, scope?: any): string;
 
+   /**
+   * Fires when a section plane is created.
+   * @param {String} event The sectionPlaneCreated event
+   * @param {Function} callback Callback fired on the event
+   */
+   on(event: "sectionPlaneCreated", callback: (measurement: SectionPlane) => void): void;
+
+   /**
+    * Fires when a measurement is destroyed.
+    * @param {String} event The sectionPlaneDestroyed event
+    * @param {Function} callback Callback fired on the event
+    */
+   on(event: "sectionPlaneDestroyed", callback: (measurement: SectionPlane) => void): void;
+
   /**
    * The epoch time (in milliseconds since 1970) when this Scene was instantiated.
    */
@@ -96,6 +111,14 @@ export declare class Scene extends Component {
    */
   get objects(): {[key: string]: Entity};
 
+  /**
+   * Map of {@link SectionPlane}s that represent sliced section planes.
+   *
+   * Each {@link SectionPlane} is mapped here by {@link SectionPlane.id}.
+   * @type {{String:SectionPlane}}
+   */
+  get sectionPlanes(): { [key: string]: SectionPlane };
+
   /**
    * Map of currently visible {@link Entity}s that represent objects.
    *