@xeokit/xeokit-sdk 2.6.40 → 2.6.42

package/dist/xeokit-sdk.es.js

@@ -11349,6 +11349,122 @@ function activateDraggableDots(cfg) {
     };
 }
 
+const touchPointSelector$1 = function(viewer, pointerCircle, ray2WorldPos) {
+    return function(onCancel, onChange, onCommit) {
+        const scene = viewer.scene;
+        const canvas = scene.canvas.canvas;
+        const longTouchTimeoutMs = 300;
+        const moveTolerance = 20;
+
+        const copyCanvasPos = (event, vec2) => {
+            vec2[0] = event.clientX;
+            vec2[1] = event.clientY;
+            transformToNode(canvas.ownerDocument.documentElement, canvas, vec2);
+            return vec2;
+        };
+
+        const pickWorldPos = canvasPos => {
+            const origin = math.vec3();
+            const direction = math.vec3();
+            math.canvasPosToWorldRay(canvas, scene.camera.viewMatrix, scene.camera.projMatrix, scene.camera.projection, canvasPos, origin, direction);
+            return ray2WorldPos(origin, direction);
+        };
+
+        let longTouchTimeout = null;
+        const nop = () => { };
+        let onSingleTouchMove = nop;
+        let startTouchIdentifier;
+
+        const resetAction = function() {
+            pointerCircle.stop();
+            clearTimeout(longTouchTimeout);
+            viewer.cameraControl.active = true;
+            onSingleTouchMove = nop;
+            startTouchIdentifier = null;
+        };
+
+        const cleanup = function() {
+            resetAction();
+            canvas.removeEventListener("touchstart", onCanvasTouchStart);
+            canvas.removeEventListener("touchmove",  onCanvasTouchMove);
+            canvas.removeEventListener("touchend",   onCanvasTouchEnd);
+        };
+
+        const onCanvasTouchStart = function(event) {
+            const touches = event.touches;
+
+            if (touches.length !== 1)
+            {
+                resetAction();
+                onCancel();
+            }
+            else
+            {
+                const startTouch = touches[0];
+                const startCanvasPos = copyCanvasPos(startTouch, math.vec2());
+
+                const startWorldPos = pickWorldPos(startCanvasPos);
+                if (startWorldPos)
+                {
+                    startTouchIdentifier = startTouch.identifier;
+
+                    onSingleTouchMove = canvasPos => {
+                        if (math.distVec2(startCanvasPos, canvasPos) > moveTolerance)
+                        {
+                            resetAction();
+                        }
+                    };
+
+                    longTouchTimeout = setTimeout(
+                        function() {
+                            pointerCircle.start(startCanvasPos);
+
+                            longTouchTimeout = setTimeout(
+                                function() {
+                                    pointerCircle.stop();
+
+                                    viewer.cameraControl.active = false;
+
+                                    onSingleTouchMove = canvasPos => {
+                                        onChange(canvasPos, pickWorldPos(canvasPos));
+                                    };
+
+                                    onSingleTouchMove(startCanvasPos);
+                                },
+                                longTouchTimeoutMs);
+                        },
+                        250);
+                }
+            }
+        };
+        canvas.addEventListener("touchstart", onCanvasTouchStart, {passive: true});
+
+        // canvas.addEventListener("touchcancel", e => console.log("touchcancel", e), {passive: true});
+
+        const onCanvasTouchMove = function(event) {
+            const touch = [...event.changedTouches].find(e => e.identifier === startTouchIdentifier);
+            if (touch)
+            {
+                onSingleTouchMove(copyCanvasPos(touch, math.vec2()));
+            }
+        };
+        canvas.addEventListener("touchmove", onCanvasTouchMove, {passive: true});
+
+        const onCanvasTouchEnd = function(event) {
+            const touch = [...event.changedTouches].find(e => e.identifier === startTouchIdentifier);
+            if (touch)
+            {
+                cleanup();
+                const canvasPos = copyCanvasPos(touch, math.vec2());
+                onCommit(canvasPos, pickWorldPos(canvasPos));
+            }
+        };
+        canvas.addEventListener("touchend", onCanvasTouchEnd, {passive: true});
+
+        return cleanup;
+    };
+};
+
 /** @private */
 class Wire {
 
@@ -56014,9 +56130,9 @@ const configs$2 = new Configs();
  */
 class VBOBatchingTrianglesBuffer {
 
-    constructor() {
-        this.maxVerts = configs$2.maxGeometryBatchSize;
-        this.maxIndices = configs$2.maxGeometryBatchSize * 3; // Rough rule-of-thumb
+    constructor(maxBatchSize = configs$2.maxGeometryBatchSize) {
+        this.maxVerts = maxBatchSize;
+        this.maxIndices = maxBatchSize * 3; // Rough rule-of-thumb
         this.positions = [];
         this.colors = [];
         this.uv = [];
@@ -67520,27 +67636,6 @@ function getRenderers$3(scene) {
     return renderers;
 }
 
-/**
- * @private
- */
-class VBOBatchingPointsBuffer {
-
-    constructor(maxGeometryBatchSize = 5000000) {
-
-        if (maxGeometryBatchSize > 5000000) {
-            maxGeometryBatchSize = 5000000;
-        }
-
-        this.maxVerts = maxGeometryBatchSize;
-        this.maxIndices = maxGeometryBatchSize * 3; // Rough rule-of-thumb
-        this.positions = [];
-        this.colors = [];
-        this.intensities = [];
-        this.pickColors = [];
-        this.offsets = [];
-    }
-}
-
 /**
  * @private
  */
@@ -67579,7 +67674,58 @@ class VBOBatchingPointsLayer {
 
         this._renderers = getRenderers$3(cfg.model.scene);
 
-        this._buffer = new VBOBatchingPointsBuffer(cfg.maxGeometryBatchSize);
+        const maxGeometryBatchSize = Math.min(5000000, cfg.maxGeometryBatchSize || window.Infinity);
+
+        const attribute = function() {
+            const portions = [ ];
+
+            return {
+                append: function(data, times = 1, denormalizeScale = 1.0) {
+                    portions.push({ data: data, times: times, denormalizeScale: denormalizeScale });
+                },
+                compileBuffer: function(type) {
+                    let len = 0;
+                    portions.forEach(p => { len += p.times * p.data.length; });
+                    const buf = new type(len);
+
+                    let begin = 0;
+                    portions.forEach(p => {
+                        const data = p.data;
+                        const dScale = p.denormalizeScale;
+                        const subBuf = buf.subarray(begin);
+
+                        if (dScale === 1.0) {
+                            subBuf.set(data, 0);
+                        } else {
+                            for (let i = 0; i < data.length; ++i) {
+                                subBuf[i] = data[i] * dScale;
+                            }
+                        }
+
+                        let soFar = data.length;
+                        const allDataLen = p.times * data.length;
+                        while (soFar < allDataLen) {
+                            const toCopy = Math.min(soFar, allDataLen - soFar);
+                            subBuf.set(subBuf.subarray(0, toCopy), soFar);
+                            soFar += toCopy;
+                        }
+
+                        begin += soFar;
+                    });
+
+                    return buf;
+                }
+            };
+        };
+
+        this._buffer = {
+            maxVerts:   maxGeometryBatchSize,
+            positions:  attribute(),
+            colors:     attribute(),
+            pickColors: attribute(),
+            vertsIndex: 0
+        };
+
         this._scratchMemory = cfg.scratchMemory;
 
         this._state = new RenderState({
@@ -67644,7 +67790,7 @@ class VBOBatchingPointsLayer {
         if (this._finalized) {
             throw "Already finalized";
         }
-        return ((this._buffer.positions.length + lenPositions) < (this._buffer.maxVerts * 3));
+        return (this._buffer.vertsIndex + (lenPositions / 3)) < this._buffer.maxVerts;
     }
 
     /**
@@ -67669,97 +67815,40 @@ class VBOBatchingPointsLayer {
             throw "Already finalized";
         }
 
-        const positions = cfg.positions;
-        const positionsCompressed = cfg.positionsCompressed;
-        const color = cfg.color;
-        const colorsCompressed = cfg.colorsCompressed;
-        const colors = cfg.colors;
-        const pickColor = cfg.pickColor;
-
         const buffer = this._buffer;
-        const positionsIndex = buffer.positions.length;
-        const vertsIndex = positionsIndex / 3;
 
-        let numVerts;
-
-        math.expandAABB3(this._modelAABB, cfg.aabb);
-
-        if (this._preCompressedPositionsExpected) {
-
-            if (!positionsCompressed) {
-                throw "positionsCompressed expected";
-            }
-
-            for (let i = 0, len = positionsCompressed.length; i < len; i++) {
-                buffer.positions.push(positionsCompressed[i]);
-            }
-
-            numVerts = positionsCompressed.length / 3;
-
-        } else {
-
-            if (!positions) {
-                throw "positions expected";
-            }
+        const positions = this._preCompressedPositionsExpected ? cfg.positionsCompressed : cfg.positions;
+        if (! positions) {
+            throw ((this._preCompressedPositionsExpected ? "positionsCompressed" : "positions") + " expected");
+        }
 
-            numVerts = positions.length / 3;
+        buffer.positions.append(positions);
 
-            positions.length;
-            buffer.positions.length;
+        const numVerts = positions.length / 3;
 
-            for (let i = 0, len = positions.length; i < len; i++) {
-                buffer.positions.push(positions[i]);
-            }
-        }
+        const color = cfg.color;
+        const colorsCompressed = cfg.colorsCompressed;
+        const colors = cfg.colors;
+        const pickColor = cfg.pickColor;
 
         if (colorsCompressed) {
-            for (let i = 0, len = colorsCompressed.length; i < len; i++) {
-                buffer.colors.push(colorsCompressed[i]);
-            }
-
+            buffer.colors.append(colorsCompressed);
         } else if (colors) {
-            for (let i = 0, len = colors.length; i < len; i++) {
-                buffer.colors.push(colors[i] * 255);
-            }
-
+            buffer.colors.append(colors, 1, 255.0);
         } else if (color) {
-
-            const r = color[0]; // Color is pre-quantized by VBOSceneModel
-            const g = color[1];
-            const b = color[2];
-            const a = 1.0;
-
-            for (let i = 0; i < numVerts; i++) {
-                buffer.colors.push(r);
-                buffer.colors.push(g);
-                buffer.colors.push(b);
-                buffer.colors.push(a);
-            }
+            // Color is pre-quantized by VBOSceneModel
+            buffer.colors.append([ color[0], color[1], color[2], 1.0 ], numVerts);
         }
 
-        {
-            const pickColorsBase = buffer.pickColors.length;
-            const lenPickColors = numVerts * 4;
-            for (let i = pickColorsBase, len = pickColorsBase + lenPickColors; i < len; i += 4) {
-                buffer.pickColors.push(pickColor[0]);
-                buffer.pickColors.push(pickColor[1]);
-                buffer.pickColors.push(pickColor[2]);
-                buffer.pickColors.push(pickColor[3]);
-            }
-        }
+        buffer.pickColors.append(pickColor.slice(0, 4), numVerts);
 
-        if (this.model.scene.entityOffsetsEnabled) {
-            for (let i = 0; i < numVerts; i++) {
-                buffer.offsets.push(0);
-                buffer.offsets.push(0);
-                buffer.offsets.push(0);
-            }
-        }
+        math.expandAABB3(this._modelAABB, cfg.aabb);
 
         const portionId = this._portions.length / 2;
 
-        this._portions.push(vertsIndex);
+        this._portions.push(this._buffer.vertsIndex);
         this._portions.push(numVerts);
+        this._buffer.vertsIndex += numVerts;
 
         this._numPortions++;
         this.model.numPortions++;
@@ -67780,43 +67869,20 @@ class VBOBatchingPointsLayer {
         const state = this._state;
         const gl = this.model.scene.canvas.gl;
         const buffer = this._buffer;
+        const maybeCreateGlBuffer = (srcData, size, usage) => (srcData.length > 0) ? new ArrayBuf(gl, gl.ARRAY_BUFFER, srcData, srcData.length, size, usage) : null;
 
-        if (buffer.positions.length > 0) {
-            if (this._preCompressedPositionsExpected) {
-                const positions = new Uint16Array(buffer.positions);
-                state.positionsBuf = new ArrayBuf(gl, gl.ARRAY_BUFFER, positions, buffer.positions.length, 3, gl.STATIC_DRAW);
-            } else {
-                const positions = new Float32Array(buffer.positions);
-                const quantizedPositions = quantizePositions(positions, this._modelAABB, state.positionsDecodeMatrix);
-                state.positionsBuf = new ArrayBuf(gl, gl.ARRAY_BUFFER, quantizedPositions, buffer.positions.length, 3, gl.STATIC_DRAW);
-            }
-        }
+        const positions = (this._preCompressedPositionsExpected
+                           ? buffer.positions.compileBuffer(Uint16Array)
+                           : (quantizePositions(buffer.positions.compileBuffer(Float32Array), this._modelAABB, state.positionsDecodeMatrix)));
+        state.positionsBuf  = maybeCreateGlBuffer(positions, 3, gl.STATIC_DRAW);
 
-        if (buffer.colors.length > 0) {
-            const colors = new Uint8Array(buffer.colors);
-            let normalized = false;
-            state.colorsBuf = new ArrayBuf(gl, gl.ARRAY_BUFFER, colors, buffer.colors.length, 4, gl.STATIC_DRAW, normalized);
-        }
+        state.flagsBuf      = maybeCreateGlBuffer(new Float32Array(this._buffer.vertsIndex), 1, gl.DYNAMIC_DRAW); // Because we build flags arrays here, get their length from the positions array
 
-        if (buffer.positions.length > 0) { // Because we build flags arrays here, get their length from the positions array
-            const flagsLength = buffer.positions.length / 3;
-            const flags = new Float32Array(flagsLength);
-            let notNormalized = false;
-            state.flagsBuf = new ArrayBuf(gl, gl.ARRAY_BUFFER, flags, flags.length, 1, gl.DYNAMIC_DRAW, notNormalized);
-        }
+        state.colorsBuf     = maybeCreateGlBuffer(buffer.colors.compileBuffer(Uint8Array), 4, gl.STATIC_DRAW);
 
-        if (buffer.pickColors.length > 0) {
-            const pickColors = new Uint8Array(buffer.pickColors);
-            let normalized = false;
-            state.pickColorsBuf = new ArrayBuf(gl, gl.ARRAY_BUFFER, pickColors, buffer.pickColors.length, 4, gl.STATIC_DRAW, normalized);
-        }
+        state.pickColorsBuf = maybeCreateGlBuffer(buffer.pickColors.compileBuffer(Uint8Array), 4, gl.STATIC_DRAW);
 
-        if (this.model.scene.entityOffsetsEnabled) {
-            if (buffer.offsets.length > 0) {
-                const offsets = new Float32Array(buffer.offsets);
-                state.offsetsBuf = new ArrayBuf(gl, gl.ARRAY_BUFFER, offsets, buffer.offsets.length, 3, gl.DYNAMIC_DRAW);
-            }
-        }
+        state.offsetsBuf    = this.model.scene.entityOffsetsEnabled ? maybeCreateGlBuffer(new Float32Array(this._buffer.vertsIndex * 3), 3, gl.DYNAMIC_DRAW) : null;
 
         this._buffer = null;
         this._finalized = true;
@@ -85116,7 +85182,21 @@ class SceneModel extends Component {
         if (cfg.image) { // Ignore transcoder for Images
             const image = cfg.image;
             image.crossOrigin = "Anonymous";
-            texture.setImage(image, {minFilter, magFilter, wrapS, wrapT, wrapR, flipY: cfg.flipY, encoding});
+            if (image.compressed) {
+                // see `parsedImage` in @loaders.gl/gltf/src/lib/parsers/parse-gltf.ts
+                // NOTE: @loaders.gl in its current version discards potential mipmaps, leaving only a single one
+                const data = image.data;
+                texture.setCompressedData({
+                    mipmaps: data,
+                    props: {
+                        format: data[0].format,
+                        minFilter: minFilter,
+                        magFilter: magFilter
+                    }
+                });
+            } else {
+                texture.setImage(image, {minFilter, magFilter, wrapS, wrapT, wrapR, flipY: cfg.flipY, encoding});
+            }
         } else if (cfg.src) {
             const ext = cfg.src.split('.').pop();
             switch (ext) { // Don't transcode recognized image file types
@@ -88040,6 +88120,7 @@ class DistanceMeasurement extends Component {
         this._visible = false;
         this._originVisible = false;
         this._targetVisible = false;
+        this._useRotationAdjustment = false;
         this._wireVisible = false;
         this._axisVisible = false;
         this._xAxisVisible = false;
@@ -88116,7 +88197,7 @@ class DistanceMeasurement extends Component {
         this.lengthLabelEnabled = cfg.lengthLabelEnabled;
         this.labelsVisible = cfg.labelsVisible;
         this.labelsOnWires = cfg.labelsOnWires;
-        this.useRotationAdjustment = cfg.useRotationAdjustment;
+        this._useRotationAdjustment = cfg.useRotationAdjustment;
 
         /**
          * @type {number[]}
@@ -88178,7 +88259,7 @@ class DistanceMeasurement extends Component {
             this._factors = math.transformVec3(this._axesBasis, delta);
 
             this._measurementOrientation = determineMeasurementOrientation(this._originWorld, this._targetWorld, 0);
-            if(this._measurementOrientation === 'Vertical' && this.useRotationAdjustment){
+            if (this._measurementOrientation === 'Vertical' && this._useRotationAdjustment) {
                 this._wp[0] = this._originWorld[0];
                 this._wp[1] = this._originWorld[1];
                 this._wp[2] = this._originWorld[2];
@@ -88388,7 +88469,7 @@ class DistanceMeasurement extends Component {
                 }
 
                 if (!this._zAxisLabelCulled) {
-                    if(this._measurementOrientation === 'Vertical' && this.useRotationAdjustment) {
+                    if (this._measurementOrientation === 'Vertical' && this._useRotationAdjustment) {
                         this._zAxisLabel.setPrefix("");
                         this._zAxisLabel.setText(tilde + Math.abs(math.lenVec3(math.subVec3(this._targetWorld, [this._originWorld[0], this._targetWorld[1], this._originWorld[2]], distVec3)) * scale).toFixed(2) + unitAbbrev);
                     }
@@ -88583,6 +88664,25 @@ class DistanceMeasurement extends Component {
         return this._targetVisible;
     }
 
+    /**
+     * Sets if the measurement is adjusted based on rotation
+     *
+     * @type {Boolean}
+     */
+    set useRotationAdjustment(value) {
+        value = value !== undefined ? Boolean(value) : this.plugin.useRotationAdjustment;
+        this._useRotationAdjustment = value;
+    }
+
+    /**
+     * Gets if the measurement is adjusted based on rotation
+     *
+     * @type {Boolean}
+     */
+    get useRotationAdjustment() {
+        return this._useRotationAdjustment;
+    }
+
     /**
      * Sets if the axis-aligned wires between {@link DistanceMeasurement#origin} and {@link DistanceMeasurement#target} are enabled.
      *
@@ -123617,7 +123717,13 @@ class StoreyViewsPlugin extends Plugin {
         return null;
     }
 
-    isPositionAboveOrBelowBuilding(worldPos){
+    /**
+     * Returns whether a position is above or below a building
+     * 
+     * @param {Number[]} worldPos 3D World-space position.
+     * @returns {String} ID of the lowest/highest story or null.
+     */
+    isPositionAboveOrBelowBuilding(worldPos) {
         const keys = Object.keys(this.storeys);
         const ids = [keys[0], keys[keys.length-1]];
         if(worldPos[1] < this.storeys[ids[0]].storeyAABB[1])
@@ -126769,6 +126875,8 @@ class TreeViewPlugin extends Plugin {
             return; // Node may not exist for the given object if (this._pruneEmptyNodes == true)
         }
 
+        this.collapse();
+
         const nodeId = node.nodeId;
 
         const switchElement = this._renderService.getSwitchElement(nodeId);
@@ -140501,122 +140609,6 @@ const mousePointSelector = function(viewer, ray2WorldPos) {
     };
 };
 
-const touchPointSelector = function(viewer, pointerCircle, ray2WorldPos) {
-    return function(onCancel, onChange, onCommit) {
-        const scene = viewer.scene;
-        const canvas = scene.canvas.canvas;
-        const longTouchTimeoutMs = 300;
-        const moveTolerance = 20;
-
-        const copyCanvasPos = (event, vec2) => {
-            vec2[0] = event.clientX;
-            vec2[1] = event.clientY;
-            transformToNode(canvas.ownerDocument.documentElement, canvas, vec2);
-            return vec2;
-        };
-
-        const pickWorldPos = canvasPos => {
-            const origin = math.vec3();
-            const direction = math.vec3();
-            math.canvasPosToWorldRay(canvas, scene.camera.viewMatrix, scene.camera.projMatrix, scene.camera.projection, canvasPos, origin, direction);
-            return ray2WorldPos(origin, direction);
-        };
-
-        let longTouchTimeout = null;
-        const nop = () => { };
-        let onSingleTouchMove = nop;
-        let startTouchIdentifier;
-
-        const resetAction = function() {
-            pointerCircle.stop();
-            clearTimeout(longTouchTimeout);
-            viewer.cameraControl.active = true;
-            onSingleTouchMove = nop;
-            startTouchIdentifier = null;
-        };
-
-        const cleanup = function() {
-            resetAction();
-            canvas.removeEventListener("touchstart", onCanvasTouchStart);
-            canvas.removeEventListener("touchmove",  onCanvasTouchMove);
-            canvas.removeEventListener("touchend",   onCanvasTouchEnd);
-        };
-
-        const onCanvasTouchStart = function(event) {
-            const touches = event.touches;
-
-            if (touches.length !== 1)
-            {
-                resetAction();
-                onCancel();
-            }
-            else
-            {
-                const startTouch = touches[0];
-                const startCanvasPos = copyCanvasPos(startTouch, math.vec2());
-
-                const startWorldPos = pickWorldPos(startCanvasPos);
-                if (startWorldPos)
-                {
-                    startTouchIdentifier = startTouch.identifier;
-
-                    onSingleTouchMove = canvasPos => {
-                        if (math.distVec2(startCanvasPos, canvasPos) > moveTolerance)
-                        {
-                            resetAction();
-                        }
-                    };
-
-                    longTouchTimeout = setTimeout(
-                        function() {
-                            pointerCircle.start(startCanvasPos);
-
-                            longTouchTimeout = setTimeout(
-                                function() {
-                                    pointerCircle.stop();
-
-                                    viewer.cameraControl.active = false;
-
-                                    onSingleTouchMove = canvasPos => {
-                                        onChange(canvasPos, pickWorldPos(canvasPos));
-                                    };
-
-                                    onSingleTouchMove(startCanvasPos);
-                                },
-                                longTouchTimeoutMs);
-                        },
-                        250);
-                }
-            }
-        };
-        canvas.addEventListener("touchstart", onCanvasTouchStart, {passive: true});
-
-        // canvas.addEventListener("touchcancel", e => console.log("touchcancel", e), {passive: true});
-
-        const onCanvasTouchMove = function(event) {
-            const touch = [...event.changedTouches].find(e => e.identifier === startTouchIdentifier);
-            if (touch)
-            {
-                onSingleTouchMove(copyCanvasPos(touch, math.vec2()));
-            }
-        };
-        canvas.addEventListener("touchmove", onCanvasTouchMove, {passive: true});
-
-        const onCanvasTouchEnd = function(event) {
-            const touch = [...event.changedTouches].find(e => e.identifier === startTouchIdentifier);
-            if (touch)
-            {
-                cleanup();
-                const canvasPos = copyCanvasPos(touch, math.vec2());
-                onCommit(canvasPos, pickWorldPos(canvasPos));
-            }
-        };
-        canvas.addEventListener("touchend", onCanvasTouchEnd, {passive: true});
-
-        return cleanup;
-    };
-};
-
 const planeIntersect = function(p0, n, origin, direction) {
     const t = - (math.dotVec3(origin, n) - p0) / math.dotVec3(direction, n);
     {
@@ -141957,4 +141949,4 @@ class ZoneTranslateTouchControl extends ZoneTranslateControl {
     }
 }
 
-export { AlphaFormat, AmbientLight, AngleMeasurementEditMouseControl, AngleMeasurementEditTouchControl, AngleMeasurementsControl, AngleMeasurementsMouseControl, AngleMeasurementsPlugin, AngleMeasurementsTouchControl, AnnotationsPlugin, AxisGizmoPlugin, BCFViewpointsPlugin, Bitmap, ByteType, CameraMemento, CameraPath, CameraPathAnimation, CityJSONLoaderPlugin, ClampToEdgeWrapping, Component, CompressedMediaType, Configs, ContextMenu, CubicBezierCurve, Curve, DefaultLoadingManager, DepthFormat, DepthStencilFormat, DirLight, DistanceMeasurementEditControl, DistanceMeasurementEditMouseControl, DistanceMeasurementEditTouchControl, DistanceMeasurementsControl, DistanceMeasurementsMouseControl, DistanceMeasurementsPlugin, DistanceMeasurementsTouchControl, DotBIMDefaultDataSource, DotBIMLoaderPlugin, EdgeMaterial, EmphasisMaterial, FaceAlignedSectionPlanesPlugin, FastNavPlugin, FloatType, Fresnel, Frustum$1 as Frustum, FrustumPlane, GIFMediaType, GLTFDefaultDataSource, GLTFLoaderPlugin, HalfFloatType, ImagePlane, IntType, JPEGMediaType, KTX2TextureTranscoder, LASLoaderPlugin, LambertMaterial, LightMap, LineSet, LinearEncoding, LinearFilter, LinearMipMapLinearFilter, LinearMipMapNearestFilter, LinearMipmapLinearFilter, LinearMipmapNearestFilter, Loader, LoadingManager, LocaleService, LuminanceAlphaFormat, LuminanceFormat, Map$1 as Map, Marker, MarqueePicker, MarqueePickerMouseControl, Mesh, MeshSurfaceArea, MeshVolume, MetallicMaterial, MirroredRepeatWrapping, ModelMemento, NavCubePlugin, NearestFilter, NearestMipMapLinearFilter, NearestMipMapNearestFilter, NearestMipmapLinearFilter, NearestMipmapNearestFilter, Node$2 as Node, OBJLoaderPlugin, ObjectsKdTree3, ObjectsMemento, PNGMediaType, Path, PerformanceModel, PhongMaterial, PickResult, Plugin, PointLight, PointerCircle, PointerLens, QuadraticBezierCurve, Queue, RGBAFormat, RGBAIntegerFormat, RGBA_ASTC_10x10_Format, RGBA_ASTC_10x5_Format, RGBA_ASTC_10x6_Format, RGBA_ASTC_10x8_Format, RGBA_ASTC_12x10_Format, RGBA_ASTC_12x12_Format, RGBA_ASTC_4x4_Format, RGBA_ASTC_5x4_Format, RGBA_ASTC_5x5_Format, RGBA_ASTC_6x5_Format, RGBA_ASTC_6x6_Format, RGBA_ASTC_8x5_Format, RGBA_ASTC_8x6_Format, RGBA_ASTC_8x8_Format, RGBA_BPTC_Format, RGBA_ETC2_EAC_Format, RGBA_PVRTC_2BPPV1_Format, RGBA_PVRTC_4BPPV1_Format, RGBA_S3TC_DXT1_Format, RGBA_S3TC_DXT3_Format, RGBA_S3TC_DXT5_Format, RGBFormat, RGB_ETC1_Format, RGB_ETC2_Format, RGB_PVRTC_2BPPV1_Format, RGB_PVRTC_4BPPV1_Format, RGB_S3TC_DXT1_Format, RGFormat, RGIntegerFormat, ReadableGeometry, RedFormat, RedIntegerFormat, ReflectionMap, RepeatWrapping, STLDefaultDataSource, STLLoaderPlugin, SceneModel, SceneModelMesh, SceneModelTransform, SectionPlane, SectionPlanesPlugin, ShortType, Skybox, SkyboxesPlugin, SpecularMaterial, SplineCurve, SpriteMarker, StoreyViewsPlugin, Texture, TextureTranscoder, TreeViewPlugin, UnsignedByteType, UnsignedInt248Type, UnsignedIntType, UnsignedShort4444Type, UnsignedShort5551Type, UnsignedShortType, VBOGeometry, ViewCullPlugin, Viewer, WebIFCLoaderPlugin, WorkerPool$1 as WorkerPool, XKTDefaultDataSource, XKTLoaderPlugin, XML3DLoaderPlugin, ZoneEditControl, ZoneEditMouseControl, ZoneEditTouchControl, ZoneTranslateControl, ZoneTranslateMouseControl, ZoneTranslateTouchControl, ZonesMouseControl, ZonesPlugin, ZonesPolysurfaceMouseControl, ZonesPolysurfaceTouchControl, ZonesTouchControl, buildBoxGeometry, buildBoxLinesGeometry, buildBoxLinesGeometryFromAABB, buildCylinderGeometry, buildGridGeometry, buildLineGeometry, buildPlaneGeometry, buildPolylineGeometry, buildPolylineGeometryFromCurve, buildSphereGeometry, buildTorusGeometry, buildVectorTextGeometry, createRTCViewMat, frustumIntersectsAABB3, getKTX2TextureTranscoder, getPlaneRTCPos, isTriangleMeshSolid, load3DSGeometry, loadOBJGeometry, math, meshSurfaceArea, meshVolume, rtcToWorldPos, sRGBEncoding, setFrustum, stats, utils, worldToRTCPos, worldToRTCPositions };
+export { AlphaFormat, AmbientLight, AngleMeasurementEditMouseControl, AngleMeasurementEditTouchControl, AngleMeasurementsControl, AngleMeasurementsMouseControl, AngleMeasurementsPlugin, AngleMeasurementsTouchControl, AnnotationsPlugin, AxisGizmoPlugin, BCFViewpointsPlugin, Bitmap, ByteType, CameraMemento, CameraPath, CameraPathAnimation, CityJSONLoaderPlugin, ClampToEdgeWrapping, Component, CompressedMediaType, Configs, ContextMenu, CubicBezierCurve, Curve, DefaultLoadingManager, DepthFormat, DepthStencilFormat, DirLight, DistanceMeasurementEditControl, DistanceMeasurementEditMouseControl, DistanceMeasurementEditTouchControl, DistanceMeasurementsControl, DistanceMeasurementsMouseControl, DistanceMeasurementsPlugin, DistanceMeasurementsTouchControl, Dot3D, DotBIMDefaultDataSource, DotBIMLoaderPlugin, EdgeMaterial, EmphasisMaterial, FaceAlignedSectionPlanesPlugin, FastNavPlugin, FloatType, Fresnel, Frustum$1 as Frustum, FrustumPlane, GIFMediaType, GLTFDefaultDataSource, GLTFLoaderPlugin, HalfFloatType, ImagePlane, IntType, JPEGMediaType, KTX2TextureTranscoder, LASLoaderPlugin, LambertMaterial, LightMap, LineSet, LinearEncoding, LinearFilter, LinearMipMapLinearFilter, LinearMipMapNearestFilter, LinearMipmapLinearFilter, LinearMipmapNearestFilter, Loader, LoadingManager, LocaleService, LuminanceAlphaFormat, LuminanceFormat, Map$1 as Map, Marker, MarqueePicker, MarqueePickerMouseControl, Mesh, MeshSurfaceArea, MeshVolume, MetallicMaterial, MirroredRepeatWrapping, ModelMemento, NavCubePlugin, NearestFilter, NearestMipMapLinearFilter, NearestMipMapNearestFilter, NearestMipmapLinearFilter, NearestMipmapNearestFilter, Node$2 as Node, OBJLoaderPlugin, ObjectsKdTree3, ObjectsMemento, PNGMediaType, Path, PerformanceModel, PhongMaterial, PickResult, Plugin, PointLight, PointerCircle, PointerLens, QuadraticBezierCurve, Queue, RGBAFormat, RGBAIntegerFormat, RGBA_ASTC_10x10_Format, RGBA_ASTC_10x5_Format, RGBA_ASTC_10x6_Format, RGBA_ASTC_10x8_Format, RGBA_ASTC_12x10_Format, RGBA_ASTC_12x12_Format, RGBA_ASTC_4x4_Format, RGBA_ASTC_5x4_Format, RGBA_ASTC_5x5_Format, RGBA_ASTC_6x5_Format, RGBA_ASTC_6x6_Format, RGBA_ASTC_8x5_Format, RGBA_ASTC_8x6_Format, RGBA_ASTC_8x8_Format, RGBA_BPTC_Format, RGBA_ETC2_EAC_Format, RGBA_PVRTC_2BPPV1_Format, RGBA_PVRTC_4BPPV1_Format, RGBA_S3TC_DXT1_Format, RGBA_S3TC_DXT3_Format, RGBA_S3TC_DXT5_Format, RGBFormat, RGB_ETC1_Format, RGB_ETC2_Format, RGB_PVRTC_2BPPV1_Format, RGB_PVRTC_4BPPV1_Format, RGB_S3TC_DXT1_Format, RGFormat, RGIntegerFormat, ReadableGeometry, RedFormat, RedIntegerFormat, ReflectionMap, RepeatWrapping, STLDefaultDataSource, STLLoaderPlugin, SceneModel, SceneModelMesh, SceneModelTransform, SectionPlane, SectionPlanesPlugin, ShortType, Skybox, SkyboxesPlugin, SpecularMaterial, SplineCurve, SpriteMarker, StoreyViewsPlugin, Texture, TextureTranscoder, TreeViewPlugin, UnsignedByteType, UnsignedInt248Type, UnsignedIntType, UnsignedShort4444Type, UnsignedShort5551Type, UnsignedShortType, VBOGeometry, ViewCullPlugin, Viewer, WebIFCLoaderPlugin, WorkerPool$1 as WorkerPool, XKTDefaultDataSource, XKTLoaderPlugin, XML3DLoaderPlugin, ZoneEditControl, ZoneEditMouseControl, ZoneEditTouchControl, ZoneTranslateControl, ZoneTranslateMouseControl, ZoneTranslateTouchControl, ZonesMouseControl, ZonesPlugin, ZonesPolysurfaceMouseControl, ZonesPolysurfaceTouchControl, ZonesTouchControl, activateDraggableDot, activateDraggableDots, buildBoxGeometry, buildBoxLinesGeometry, buildBoxLinesGeometryFromAABB, buildCylinderGeometry, buildGridGeometry, buildLineGeometry, buildPlaneGeometry, buildPolylineGeometry, buildPolylineGeometryFromCurve, buildSphereGeometry, buildTorusGeometry, buildVectorTextGeometry, createRTCViewMat, frustumIntersectsAABB3, getKTX2TextureTranscoder, getPlaneRTCPos, isTriangleMeshSolid, load3DSGeometry, loadOBJGeometry, math, meshSurfaceArea, meshVolume, rtcToWorldPos, sRGBEncoding, setFrustum, stats, touchPointSelector$1 as touchPointSelector, transformToNode, utils, worldToRTCPos, worldToRTCPositions };