@aibee/owlly 1.0.26 → 1.0.29

package/lib/owlly/element/ring-element.js

@@ -0,0 +1,383 @@
+import { NS_THREE } from '../stage/externals';
+import { Element, ElementFrameContext } from './element';
+class RingElement extends Element {
+    constructor(option) {
+        super();
+        const { innerRadius, outerRadius, tubeRadius, textArrowMesh, signMesh, textMeshMap, maxLeftAngle, maxRightAngle, downMesh, } = option;
+        const geometry = new NS_THREE.RingGeometry(innerRadius, outerRadius, 540, 1);
+        const material = new NS_THREE.MeshBasicMaterial({
+            color: 0xffffff,
+            wireframe: false,
+            blending: NS_THREE.CustomBlending,
+            blendSrc: NS_THREE.OneFactor,
+        });
+        material.needsUpdate = true;
+        material.visible = true;
+        material.opacity = 1;
+        this.torus = new NS_THREE.Mesh(geometry, material);
+        this.torus.position.set(0, 0, 1);
+        this.torus.lookAt(0, 0, 1);
+        this.add(this.torus);
+        this.enabled = true;
+        this.textArrowMesh = textArrowMesh;
+        this.textArrowMesh.visible = false;
+        this.signMesh = signMesh;
+        this.signMesh.visible = false;
+        this.downMesh = downMesh;
+        this.downMesh.visible = true;
+        this.torus.add(this.textArrowMesh);
+        this.textMeshMap = textMeshMap;
+        this.textValuePre = 0;
+        this.tubeRadius = tubeRadius || 0;
+        this.maxLeftAngle = maxLeftAngle || 0;
+        this.maxRightAngle = maxRightAngle || 0;
+        this.setRing(0, '123米', 'center');
+        // console.log(this.textArrowMesh, this.textMeshMap);
+        // this.createImage(r + d / 2, d, torus);
+        // this.createText(r + d / 2, d, torus);
+        const r = innerRadius;
+        const d = outerRadius - innerRadius;
+        this.innerRadius = innerRadius;
+        this.outerRadius = outerRadius;
+        this.navRadius = r + d / 2;
+        this.createMask(innerRadius, outerRadius);
+        this.createSign(innerRadius, d);
+        this.createDown(innerRadius);
+        this.initialized = false;
+        this.needUpdate = true;
+        this.directionPre = 'center';
+    }
+    // 刻度线
+    createSign(r, d) {
+        for (let angle = 0; angle < 2 * Math.PI; angle += Math.PI / 180) {
+            const sx = Math.cos(angle) * (r + d / 2);
+            const sy = Math.sin(angle) * (r + d / 2);
+            const p = {
+                x: sy,
+                y: sx,
+            };
+            // 刻度线
+            const lineMesh = this.signMesh.clone();
+            lineMesh.position.set(p.x, p.y, 2);
+            lineMesh.lookAt(0, 0, 1);
+            if (angle < Math.PI) {
+                lineMesh.rotateY(Math.PI / 2);
+            }
+            else {
+                lineMesh.rotateY(-Math.PI / 2);
+            }
+            lineMesh.visible = true;
+            this.torus.add(lineMesh);
+        }
+    }
+    createDown(r) {
+        const downMesh = this.downMesh.clone();
+        downMesh.position.set(0, r - 10, 10);
+        this.downArrow = downMesh;
+        this.add(downMesh);
+    }
+    // 文字后面遮罩层
+    createMask(r, d) {
+        const material = new NS_THREE.MeshBasicMaterial({
+            transparent: true,
+            blending: NS_THREE.CustomBlending,
+            blendSrc: NS_THREE.OneFactor,
+            color: 0xffffff,
+        });
+        const geometry = new NS_THREE.RingGeometry(r + d / 2, r - d / 2, 540, 1, Math.PI / 2, Math.PI / 18);
+        this.maskCenterMesh = new NS_THREE.Mesh(geometry, material);
+        this.maskCenterMesh.position.set(0, 0, 3);
+        // this.maskCenterMesh.lookAt(0, 0, 1);
+        // 中心遮罩跟随圆动，两边的固定在左右
+        this.torus.add(this.maskCenterMesh);
+    }
+    // 控制圆盘的偏移以及文字显示
+    updateText(angle, value) {
+        // 计算偏移量
+        let torusOffsetAngle = angle;
+        if (this.isStop) {
+            torusOffsetAngle = 0;
+            this.direction = 'center';
+        }
+        if (this.direction === 'left') {
+            torusOffsetAngle = -this.maxLeftAngle;
+        }
+        if (this.direction === 'right') {
+            torusOffsetAngle = -this.maxRightAngle;
+        }
+        if (this.leftMeshGroup)
+            this.leftMeshGroup.visible = false;
+        if (this.centerMeshGroup)
+            this.centerMeshGroup.visible = false;
+        if (this.rightMeshGroup)
+            this.rightMeshGroup.visible = false;
+        if (this.textArrowMesh)
+            this.textArrowMesh.visible = false;
+        // 分别处理左、右、中
+        const valueText = [];
+        valueText.push(...value.toString());
+        // 判断是否更新文字
+        let textUpdate = false;
+        if (this.textValuePre !== value) {
+            textUpdate = true;
+        }
+        if (this.directionPre !== this.direction) {
+            textUpdate = true;
+        }
+        this.textValuePre = value;
+        this.directionPre = this.direction;
+        if (this.direction === 'left') {
+            // 定位在左侧
+            if (!this.leftMeshGroup) {
+                this.leftMeshGroup = this.renderText('ls'.split(''));
+                this.torus.add(this.leftMeshGroup);
+            }
+            if (textUpdate) {
+                if (this.leftTextMeshGroup)
+                    this.leftMeshGroup.remove(this.leftTextMeshGroup);
+                this.leftTextMeshGroup = this.renderText(valueText, this.leftMeshGroup.groupOffsetAngle);
+                this.leftMeshGroup.add(this.leftTextMeshGroup);
+                // 更新遮罩层
+                if (this.maskCenterMesh && textUpdate) {
+                    const g = this.maskCenterMesh.geometry;
+                    const geometry = new NS_THREE.RingGeometry(this.innerRadius, this.outerRadius, 60, 1, 0, this.leftTextMeshGroup.groupOffsetAngle - this.leftTextMeshGroup.lastAngle / 2);
+                    this.maskCenterMesh.geometry = geometry;
+                    setTimeout(() => {
+                        g.dispose();
+                    });
+                }
+            }
+            // 最大左偏移量
+            // let maxLeftAngleOffset = 0;
+            // if (torusOffsetAngle < -this.maxLeftAngle) {
+            //   maxLeftAngleOffset = torusOffsetAngle + this.maxLeftAngle;
+            //   this.leftMeshGroup.rotation.z = maxLeftAngleOffset;
+            // }
+            if (this.maskCenterMesh) {
+                this.maskCenterMesh.rotation.z = Math.PI / 2
+                    - this.leftTextMeshGroup.groupOffsetAngle
+                    + this.leftTextMeshGroup.lastAngle / 2;
+                // + maxLeftAngleOffset;
+            }
+            this.leftMeshGroup.visible = true;
+        }
+        else if (this.direction === 'right') {
+            // // 定位在右侧
+            if (!this.rightMeshGroup) {
+                this.rightMeshGroup = this.renderText('sr'.split(''), 0, true);
+                this.torus.add(this.rightMeshGroup);
+            }
+            if (textUpdate) {
+                if (this.rightTextMeshGroup)
+                    this.rightMeshGroup.remove(this.rightTextMeshGroup);
+                this.rightTextMeshGroup = this.renderText(valueText, this.rightMeshGroup.groupOffsetAngle, true);
+                // // 减去上面的旋转量，以适应文字变化
+                this.rightMeshGroup.add(this.rightTextMeshGroup);
+            }
+            this.rightMeshGroup.visible = true;
+            // 最大右偏移量
+            // let maxRightAngleOffset = 0;
+            // if (torusOffsetAngle > -this.maxRightAngle) {
+            //   maxRightAngleOffset = torusOffsetAngle + this.maxRightAngle;
+            //   this.rightMeshGroup.rotation.z = maxRightAngleOffset;
+            // }
+            // 更新遮罩层
+            if (this.maskCenterMesh && textUpdate) {
+                const g = this.maskCenterMesh.geometry;
+                const geometry = new NS_THREE.RingGeometry(this.innerRadius, this.outerRadius, 60, 1, 0, this.rightTextMeshGroup.groupOffsetAngle - this.rightTextMeshGroup.firstAngle / 2);
+                this.maskCenterMesh.geometry = geometry;
+                this.maskCenterMesh.rotation.z = Math.PI / 2;
+                setTimeout(() => {
+                    g.dispose();
+                });
+            }
+        }
+        else if (this.direction === 'center') {
+            if (textUpdate) {
+                // 文字
+                if (this.centerMeshGroup)
+                    this.torus.remove(this.centerMeshGroup);
+                this.centerMeshGroup = this.renderText(valueText);
+                this.torus.add(this.centerMeshGroup);
+                // 对正
+                this.centerMeshGroup.rotateZ(this.centerMeshGroup.groupOffsetAngle / 2);
+            }
+            this.centerMeshGroup.visible = true;
+            // 到终点达，和全屏，隐藏箭头
+            if (this.isStop || !this.showTopArrow) {
+                this.textArrowMesh.visible = false;
+            }
+            else {
+                // 顶部箭头
+                this.textArrowMesh.visible = true;
+                this.textArrowMesh.position.set(0, this.innerRadius + this.tubeRadius, 5); // 部分在圆里
+            }
+            // 更新遮罩层
+            if (this.maskCenterMesh && textUpdate) {
+                const g = this.maskCenterMesh.geometry;
+                const geometry = new NS_THREE.RingGeometry(this.innerRadius, this.outerRadius, 60, 1, 0, this.centerMeshGroup.groupOffsetAngle
+                    - this.centerMeshGroup.firstAngle / 2
+                    - this.centerMeshGroup.lastAngle / 2);
+                this.maskCenterMesh.geometry = geometry;
+                this.maskCenterMesh.rotation.z = Math.PI / 2
+                    - this.centerMeshGroup.groupOffsetAngle / 2
+                    + this.centerMeshGroup.lastAngle / 2;
+                setTimeout(() => {
+                    g.dispose();
+                });
+            }
+        }
+        if (this.isStop) {
+            this.torus.rotation.z = 0;
+        }
+        else {
+            this.torus.rotation.z = -torusOffsetAngle;
+        }
+    }
+    // 绘制文字
+    renderText(values, angle = 0, reverse = false) {
+        const textList = reverse ? values.reverse() : values;
+        // 弧度累计
+        let groupOffsetAngle = 0;
+        if (reverse) {
+            groupOffsetAngle = -angle;
+        }
+        else {
+            groupOffsetAngle = angle;
+        }
+        const textMeshGroup = new NS_THREE.Group();
+        let firstAngle = 0;
+        let lastAngle = 0;
+        textList.forEach((item, index) => {
+            const textMeshData = this.textMeshMap.get(item);
+            if (!textMeshData)
+                return;
+            const textMesh = textMeshData.mesh.clone();
+            // textMesh.material.visible = true;
+            // 文字自身宽度
+            const radian = index === 0
+                ? Math.asin(textMeshData.textWidth / 2 / this.navRadius) * 2
+                : Math.asin(textMeshData.textWidth / 2 / this.navRadius) * 2;
+            if (index === 0)
+                firstAngle = radian;
+            if (index === textList.length - 1)
+                lastAngle = radian;
+            if (reverse) {
+                groupOffsetAngle -= radian / 2;
+            }
+            else {
+                groupOffsetAngle += radian / 2;
+            }
+            // 左间距
+            if (textMeshData.spacingLeft) {
+                const rad = Math.asin(textMeshData.spacingLeft / 2 / this.navRadius) * 2;
+                if (reverse) {
+                    groupOffsetAngle -= rad;
+                }
+                else {
+                    groupOffsetAngle += rad;
+                }
+            }
+            // 定位
+            const r = this.navRadius;
+            const x = r * Math.sin(groupOffsetAngle);
+            const y = r * Math.cos(groupOffsetAngle);
+            textMesh.position.set(x, y, 15);
+            // 旋转
+            textMesh.rotateZ(-groupOffsetAngle);
+            // 横向偏移量累加
+            if (reverse) {
+                groupOffsetAngle -= radian / 2;
+            }
+            else {
+                groupOffsetAngle += radian / 2;
+            }
+            // 右间距
+            if (textMeshData.spacing) {
+                const rad = Math.asin(textMeshData.spacing / 2 / this.navRadius) * 2;
+                if (reverse) {
+                    groupOffsetAngle -= rad;
+                }
+                else {
+                    groupOffsetAngle += rad;
+                }
+            }
+            textMeshGroup.add(textMesh);
+        });
+        // 文字整体弧度
+        textMeshGroup.groupOffsetAngle = Math.abs(groupOffsetAngle);
+        textMeshGroup.lastAngle = lastAngle;
+        textMeshGroup.firstAngle = firstAngle;
+        return textMeshGroup;
+    }
+    setDirection(direction) {
+        this.direction = direction;
+    }
+    setAngle(angle) {
+        this.angle = angle;
+    }
+    setText(text) {
+        this.text = text;
+    }
+    setRing(angle, text, direction = 'center') {
+        this.setAngle(angle);
+        this.setText(text);
+        this.setDirection(direction);
+    }
+    setToursPosition(x, y, z) {
+        this.torus.position.set(x, y, z);
+    }
+    setTopArrowVisible(visible) {
+        this.showTopArrow = visible;
+    }
+    /**
+     * 设置是否更新
+     * @param value 开关值
+     */
+    setEnabled(value) {
+        this.enabled = value;
+    }
+    play() {
+        this.isStop = false;
+    }
+    /*
+     暂停时隐藏箭头，角度锁定为0
+    */
+    stop() {
+        this.isStop = true;
+    }
+    resize(width, height) {
+        if (this.viewWidth === width && this.viewHeight === height)
+            return;
+        this.viewWidth = width;
+        this.viewHeight = height;
+    }
+    update() {
+        const frameContext = new ElementFrameContext(this);
+        frameContext.needUpdate = this.needUpdate;
+        // 添加圆盘
+        if (!this.initialized && this.torus) {
+            frameContext.shouldPlaceElement = true;
+            this.initialized = true;
+        }
+        if (this.enabled) {
+            // console.log('update');
+            this.updateText(-this.angle, this.text);
+        }
+        // if (this.isStop) {
+        //   this.torus.rotation.z = 0;
+        // } else {
+        //   // this.torus.rotateZ(torusOffsetAngle);
+        //   this.torus.rotation.z = this.angle;
+        // }
+        // if (this.visible) {
+        //   frameContext.needUpdate = true;
+        // }
+        return frameContext;
+    }
+    dispose() {
+        this.torus.remove();
+        this.textMeshMap.clear();
+    }
+}
+export { RingElement };

package/lib/owlly/element/sphere-mesh.d.ts

@@ -0,0 +1,28 @@
+import { NS_THREE } from '../stage/externals';
+import { Element, ElementFrameContext } from './element';
+import { View } from '../view/view';
+declare class SphereMesh extends Element {
+    private initialized;
+    private loaded;
+    private group;
+    private eventListeners;
+    /**
+     * @param radius 半径
+     * @param optionalParams 可选参数，包括是否可见、颜色等等
+     * @example ```
+     * const sphere = new SphereMesh(0.1, { fillColor: 0x00ffff, hidden: true });
+     * sphere.position.set(0, 0, 0);
+     * stage.bindElement(sphere);
+     * ```
+     */
+    constructor(radius: number, optionalParams?: {
+        hidden?: boolean;
+        material?: NS_THREE.Material;
+        fillColor?: NS_THREE.Color | string | number;
+        opacity?: number;
+    });
+    setOnCurrentViewChanged(func: (view: View) => void): void;
+    update(): ElementFrameContext;
+    dispose(): void;
+}
+export { SphereMesh };

package/lib/owlly/element/sphere-mesh.js

@@ -0,0 +1,69 @@
+import { Externals } from '../stage/externals';
+import { Element, ElementFrameContext } from './element';
+import { BasicTools } from '../utils/basic-tools';
+// import { EventHub } from '../utils/event-hub';
+// import { OwllyEvents } from '../utils/events';
+class SphereMesh extends Element {
+    /**
+     * @param radius 半径
+     * @param optionalParams 可选参数，包括是否可见、颜色等等
+     * @example ```
+     * const sphere = new SphereMesh(0.1, { fillColor: 0x00ffff, hidden: true });
+     * sphere.position.set(0, 0, 0);
+     * stage.bindElement(sphere);
+     * ```
+     */
+    constructor(radius, optionalParams) {
+        super();
+        const { THREE } = Externals.getInstance();
+        const options = optionalParams || {};
+        this.group = new THREE.Group();
+        this.add(this.group);
+        const material = options.material || new THREE.MeshBasicMaterial({
+            color: options.fillColor ? options.fillColor : 0x00ff00,
+            transparent: true,
+            opacity: options.opacity !== undefined ? options.opacity : 1,
+            side: THREE.DoubleSide,
+            depthWrite: true,
+        });
+        if (options.hidden === false) {
+            material.visible = false;
+        }
+        const geometry = new THREE.SphereGeometry(radius, 60, 40);
+        const mesh = new THREE.Mesh(geometry, material);
+        mesh.renderOrder = 1000;
+        this.group.add(mesh);
+        this.initialized = false;
+        this.loaded = true;
+    }
+    setOnCurrentViewChanged(func) {
+        // if (this.eventListeners && this.eventListeners.onCurrentViewChanged) {
+        //   EventHub.off(OwllyEvents.RENDERING_VIEW_CHANGED, this.eventListeners.onCurrentViewChanged);
+        // }
+        this.eventListeners = {
+            onCurrentViewChanged: func,
+        };
+        // EventHub.on(OwllyEvents.RENDERING_VIEW_CHANGED, this.eventListeners.onCurrentViewChanged);
+    }
+    // renderingViewChanged(view: View): void {
+    //   if (this.eventListeners && this.eventListeners.onCurrentViewChanged) {
+    //     this.eventListeners.onCurrentViewChanged(view);
+    //   }
+    // }
+    update() {
+        const frameContext = new ElementFrameContext(this);
+        if (!this.initialized && this.loaded) {
+            this.initialized = true;
+            frameContext.needUpdate = true;
+        }
+        if (this.initialized && !this.parent) {
+            frameContext.shouldPlaceElement = true;
+        }
+        return frameContext;
+    }
+    dispose() {
+        super.dispose();
+        BasicTools.dispose(this, true);
+    }
+}
+export { SphereMesh };

package/lib/owlly/element/svg-floor-model.d.ts

@@ -0,0 +1,22 @@
+import { Element, ElementFrameContext } from './element';
+import { ModelSvgMapping } from '../view/svg-map-view';
+/**
+ * SVG楼层模型, 不应再被维护
+ * @noInheritDoc
+ * @deprecated
+ */
+declare class SvgFloorModel extends Element {
+    private initialized;
+    private loaded;
+    private opacity;
+    private mapping;
+    private groundMeshes;
+    constructor(url: string, mapping: ModelSvgMapping, opacity?: number);
+    private static getShapeDefs;
+    load(url: string): Promise<void>;
+    setOpacity(value: number): void;
+    setShadowEnabled(value: boolean): void;
+    update(): ElementFrameContext;
+    dispose(): void;
+}
+export { SvgFloorModel };

package/lib/owlly/element/svg-floor-model.js

@@ -0,0 +1,184 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { parse } from 'svgson';
+import { Externals } from '../stage/externals';
+import { Element, ElementFrameContext } from './element';
+import { SvgUtils } from '../utils/svgutils';
+import { BasicTools } from '../utils/basic-tools';
+/**
+ * SVG楼层模型, 不应再被维护
+ * @noInheritDoc
+ * @deprecated
+ */
+class SvgFloorModel extends Element {
+    constructor(url, mapping, opacity = 1) {
+        super();
+        this.initialized = false;
+        this.loaded = false;
+        this.opacity = opacity;
+        this.mapping = mapping;
+        this.groundMeshes = [];
+        if (url)
+            this.load(url);
+    }
+    static getShapeDefs(canvasObject) {
+        const result = [];
+        const { THREE } = Externals.getInstance();
+        if (canvasObject.commands && canvasObject.commands.length) {
+            const shape = new THREE.Shape();
+            const holes = [];
+            let hole = null;
+            let shapeCount = 0;
+            canvasObject.commands.forEach(({ command, args }) => {
+                if (hole && shapeCount > 1) {
+                    if (command === 'M') {
+                        if (hole)
+                            holes.push(hole);
+                        hole = new THREE.Path();
+                        hole.moveTo(args[0], args[1]);
+                    }
+                    if (command === 'C')
+                        hole.bezierCurveTo(args[0], args[1], args[2], args[3], args[4], args[5]);
+                    if (command === 'L')
+                        hole.lineTo(args[0], args[1]);
+                }
+                else {
+                    if (command === 'M') {
+                        shapeCount += 1;
+                        if (shapeCount === 2) {
+                            hole = new THREE.Path();
+                            hole.moveTo(args[0], args[1]);
+                        }
+                        else {
+                            shape.moveTo(args[0], args[1]);
+                        }
+                    }
+                    if (command === 'C')
+                        shape.bezierCurveTo(args[0], args[1], args[2], args[3], args[4], args[5]);
+                    if (command === 'L')
+                        shape.lineTo(args[0], args[1]);
+                }
+            });
+            if (hole)
+                holes.push(hole);
+            shape.holes = holes;
+            const shapeDef = { shape };
+            if (canvasObject.fill) {
+                Object.assign(shapeDef, { color: parseInt(canvasObject.fill.substr(1), 16) });
+            }
+            if (canvasObject.tag) {
+                Object.assign(shapeDef, { tag: canvasObject.tag });
+            }
+            result.push(shapeDef);
+        }
+        if (canvasObject.children && canvasObject.children.length) {
+            canvasObject.children.forEach((child) => {
+                result.push(...SvgFloorModel.getShapeDefs(child));
+            });
+        }
+        return result;
+    }
+    load(url) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.initialized = false;
+            this.loaded = false;
+            const { THREE } = Externals.getInstance();
+            // Avoid using axios. Use FileLoader instead.
+            const svg = yield new Promise((resolve) => {
+                const fileLoader = new THREE.FileLoader();
+                fileLoader.load(url, (data) => {
+                    resolve(data);
+                });
+            });
+            const svgObject = yield parse(svg);
+            const canvasObject = SvgUtils.svg2canvas(svgObject, this.mapping);
+            if (canvasObject !== null) {
+                const shapeDefs = SvgFloorModel.getShapeDefs(canvasObject);
+                const group = new THREE.Group();
+                shapeDefs.forEach(({ shape, color, tag }) => {
+                    const options = {
+                        steps: 1,
+                        depth: 1,
+                        bevelEnabled: false,
+                        bevelThickness: 0.1,
+                        bevelSize: 0.2,
+                        bevelOffset: 0,
+                        bevelSegments: 2,
+                    };
+                    switch (tag) {
+                        case 'ground':
+                            Object.assign(options, { bevelSize: 0.1, depth: 0.8 });
+                            break;
+                        case 'store':
+                            Object.assign(options, { depth: 2, bevelThickness: 0.3, bevelSize: 0.3 });
+                            break;
+                        default:
+                            break;
+                    }
+                    const geometry = new THREE.ExtrudeBufferGeometry(shape, options);
+                    const material = new THREE.MeshLambertMaterial({
+                        color,
+                        transparent: true,
+                        opacity: this.opacity,
+                    });
+                    const mesh = new THREE.Mesh(geometry, material);
+                    switch (tag) {
+                        case 'ground':
+                            mesh.receiveShadow = true;
+                            mesh.position.set(0, 0, -0.2);
+                            this.groundMeshes.push(mesh);
+                            break;
+                        case 'impassable':
+                        case 'store':
+                            mesh.castShadow = true;
+                            break;
+                        default:
+                            break;
+                    }
+                    group.add(mesh);
+                });
+                this.add(group);
+                this.loaded = true;
+            }
+        });
+    }
+    setOpacity(value) {
+        const { THREE } = Externals.getInstance();
+        this.traverse((o) => {
+            const m = o;
+            if (m.isMesh && m.material instanceof THREE.Material) {
+                m.material.opacity = value;
+            }
+        });
+    }
+    setShadowEnabled(value) {
+        this.groundMeshes.forEach((m) => {
+            // eslint-disable-next-line
+            m.receiveShadow = value;
+        });
+    }
+    update() {
+        const frameContext = new ElementFrameContext(this);
+        if (!this.initialized && this.loaded) {
+            this.initialized = true;
+            frameContext.needUpdate = true;
+        }
+        if (this.initialized && !this.parent) {
+            frameContext.shouldPlaceElement = true;
+        }
+        return frameContext;
+    }
+    dispose() {
+        super.dispose();
+        this.groundMeshes = [];
+        BasicTools.dispose(this, true);
+    }
+}
+export { SvgFloorModel };