@xviewer.js/core 1.0.1 → 1.0.2

package/dist/module.js

@@ -1,9 +1,10 @@
-import { EXRLoader } from 'three/examples/jsm/loaders/EXRLoader.js';
-import { FBXLoader } from 'three/examples/jsm/loaders/FBXLoader.js';
-import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
+import { EXRLoader as EXRLoader$1 } from 'three/examples/jsm/loaders/EXRLoader.js';
+import { FBXLoader as FBXLoader$1 } from 'three/examples/jsm/loaders/FBXLoader.js';
+import { GLTFLoader as GLTFLoader$1 } from 'three/examples/jsm/loaders/GLTFLoader.js';
 import { DRACOLoader } from 'three/examples/jsm/loaders/DRACOLoader.js';
 import { MeshoptDecoder } from 'three/examples/jsm/libs/meshopt_decoder.module.js';
-import { EquirectangularReflectionMapping, FileLoader, TextureLoader, SRGBColorSpace, MathUtils, Vector3, Quaternion, Raycaster, Vector2, LinearInterpolant, Spherical, Mesh, BoxGeometry, SphereGeometry, PlaneGeometry, Plane as Plane$1, Matrix4, Vector4, PerspectiveCamera, WebGLRenderTarget, HalfFloatType, LinearMipMapLinearFilter, LinearFilter, AnimationMixer, Color, OrthographicCamera, MeshDepthMaterial, ShaderMaterial, Euler, Group, UniformsUtils, NoBlending, AdditiveBlending, FloatType, UnsignedByteType, BufferGeometry, Float32BufferAttribute, Object3D, ClampToEdgeWrapping, NearestFilter, LinearSRGBColorSpace, WebGLCubeRenderTarget, DataTexture, RGBAFormat, UVMapping, Scene, WebGLRenderer, PCFSoftShadowMap, LoadingManager, LinearToneMapping, PMREMGenerator, CubeCamera, ShaderLib, ShaderChunk } from 'three';
+import * as THREE from 'three';
+import { EquirectangularReflectionMapping, FileLoader, TextureLoader as TextureLoader$1, SRGBColorSpace, MathUtils, Vector3, Vector2, LinearInterpolant, Quaternion, Raycaster, Spherical, Mesh, BoxGeometry, SphereGeometry, PlaneGeometry, Plane as Plane$1, Matrix4, Vector4, PerspectiveCamera, WebGLRenderTarget, HalfFloatType, LinearMipMapLinearFilter, LinearFilter, AnimationMixer, Color, OrthographicCamera, MeshDepthMaterial, ShaderMaterial, Euler, Group, REVISION, Box3, Sphere as Sphere$1, UniformsUtils, NoBlending, AdditiveBlending, FloatType, UnsignedByteType, Object3D, BufferGeometry, Float32BufferAttribute, ClampToEdgeWrapping, NearestFilter, LinearSRGBColorSpace, WebGLCubeRenderTarget, DataTexture, RGBAFormat, UVMapping, Scene, WebGLRenderer, PCFSoftShadowMap, LoadingManager, LinearToneMapping, PMREMGenerator, CubeCamera, ShaderLib, ShaderChunk } from 'three';
 import { RGBELoader } from 'three/examples/jsm/loaders/RGBELoader.js';
 import { HorizontalBlurShader, VerticalBlurShader } from 'three/examples/jsm/Addons.js';
 
@@ -140,2291 +141,632 @@ function getClassInstance(constructor, args = []) {
     return typeof constructor === "function" ? new constructor(...args) : constructor;
 }
 
-/**
- * Controlling groups of tweens
- *
- * Using the TWEEN singleton to manage your tweens can cause issues in large apps with many components.
- * In these cases, you may want to create your own smaller groups of tween
- */ class TweenGroup {
-    getAll() {
-        return Object.values(this._tweens);
-    }
-    removeAll() {
-        this._tweens = {};
-    }
-    removeOf(target) {
-        this.getAll().forEach((tween)=>tween.getObject() === target && this.remove(tween));
-    }
-    add(tween) {
-        this._tweens[tween.getId()] = tween;
-        this._tweensAddedDuringUpdate[tween.getId()] = tween;
-    }
-    remove(tween) {
-        delete this._tweens[tween.getId()];
-        delete this._tweensAddedDuringUpdate[tween.getId()];
-    }
-    update(time, preserve = false) {
-        let tweenIds = Object.keys(this._tweens);
-        if (tweenIds.length === 0) {
-            return false;
-        }
-        // Tweens are updated in "batches". If you add a new tween during an
-        // update, then the new tween will be updated in the next batch.
-        // If you remove a tween during an update, it may or may not be updated.
-        // However, if the removed tween was added during the current batch,
-        // then it will not be updated.
-        while(tweenIds.length > 0){
-            this._tweensAddedDuringUpdate = {};
-            for(let i = 0; i < tweenIds.length; i++){
-                const tween = this._tweens[tweenIds[i]];
-                const autoStart = !preserve;
-                if (tween && tween.update(time, autoStart) === false && !preserve) {
-                    delete this._tweens[tweenIds[i]];
-                }
+class Loader {
+    static _setUserData(node) {
+        const keys = Loader._texKeys;
+        const meshes = [];
+        const textures = {};
+        const materials = {};
+        const queue = [
+            node
+        ];
+        while(queue.length !== 0){
+            let object = queue.shift();
+            if (object.isMesh) {
+                meshes.push(object);
+                const mat = object.material;
+                if (Array.isArray(mat)) mat.forEach((v)=>materials[v.uuid] = v);
+                else materials[mat.uuid] = mat;
             }
-            tweenIds = Object.keys(this._tweensAddedDuringUpdate);
+            queue.push(...object.children);
         }
-        return true;
+        Object.values(materials).forEach((mat)=>{
+            keys.forEach((k)=>{
+                let tex = mat[k];
+                if (tex) {
+                    textures[tex.uuid] = tex;
+                }
+            });
+        });
+        Object.assign(node.userData, {
+            meshes,
+            materials,
+            textures
+        });
+        return node;
     }
-    constructor(){
-        this._tweens = {};
-        this._tweensAddedDuringUpdate = {};
+    constructor(manager){
+        this.manager = manager;
     }
 }
+Loader._texKeys = [
+    "map",
+    "alphaMap",
+    "aoMap",
+    "bumpMap",
+    "displacementMap",
+    "emissiveMap",
+    "envMap",
+    "lightMap",
+    "metalnessMap",
+    "normalMap",
+    "roughnessMap",
+    "specularMap",
+    "alphaMap"
+];
 
-const now = ()=>performance.now() * 0.001;
-
-/**
- * The Ease class provides a collection of easing functions for use with tween.js.
- */ const Easing = Object.freeze({
-    Linear: Object.freeze({
-        None (amount) {
-            return amount;
-        },
-        In (amount) {
-            return amount;
-        },
-        Out (amount) {
-            return amount;
-        },
-        InOut (amount) {
-            return amount;
+class EXRLoader extends Loader {
+    load({ url, path, resourcePath, manager, texSettings, onLoad, onProgress, onError }) {
+        let loader = this._loader;
+        if (loader === undefined) {
+            loader = this._loader = new EXRLoader$1();
         }
-    }),
-    Quadratic: Object.freeze({
-        In (amount) {
-            return amount * amount;
-        },
-        Out (amount) {
-            return amount * (2 - amount);
-        },
-        InOut (amount) {
-            if ((amount *= 2) < 1) {
-                return 0.5 * amount * amount;
-            }
-            return -0.5 * (--amount * (amount - 2) - 1);
+        loader.manager = manager;
+        loader.setPath(path);
+        loader.setResourcePath(resourcePath);
+        loader.load(url, (tex)=>onLoad(Object.assign(tex, texSettings)), onProgress, onError);
+    }
+    constructor(...args){
+        super(...args);
+        this.extension = [
+            "exr"
+        ];
+    }
+}
+
+class FBXLoader extends Loader {
+    load({ url, buffer, path, resourcePath, manager, onLoad, onProgress, onError }) {
+        let loader = this._loader;
+        if (loader === undefined) {
+            loader = this._loader = new FBXLoader$1();
         }
-    }),
-    Cubic: Object.freeze({
-        In (amount) {
-            return amount * amount * amount;
-        },
-        Out (amount) {
-            return --amount * amount * amount + 1;
-        },
-        InOut (amount) {
-            if ((amount *= 2) < 1) {
-                return 0.5 * amount * amount * amount;
-            }
-            return 0.5 * ((amount -= 2) * amount * amount + 2);
+        loader.manager = manager;
+        loader.setPath(path);
+        loader.setResourcePath(resourcePath);
+        const loadCallback = (node)=>{
+            onLoad(Loader._setUserData(node));
+        };
+        if (buffer) {
+            loadCallback(loader.parse(buffer, resourcePath));
+        } else {
+            loader.load(url, loadCallback, onProgress, onError);
         }
-    }),
-    Quartic: Object.freeze({
-        In (amount) {
-            return amount * amount * amount * amount;
-        },
-        Out (amount) {
-            return 1 - --amount * amount * amount * amount;
-        },
-        InOut (amount) {
-            if ((amount *= 2) < 1) {
-                return 0.5 * amount * amount * amount * amount;
-            }
-            return -0.5 * ((amount -= 2) * amount * amount * amount - 2);
+    }
+    constructor(...args){
+        super(...args);
+        this.extension = [
+            "fbx"
+        ];
+    }
+}
+
+class GLTFLoader extends Loader {
+    load({ url, buffer, path, resourcePath, dracoPath, manager, onLoad, onProgress, onError }) {
+        let dracoLoader = this._dracoLoader;
+        if (dracoLoader === undefined) {
+            dracoLoader = this._dracoLoader = new DRACOLoader();
         }
-    }),
-    Quintic: Object.freeze({
-        In (amount) {
-            return amount * amount * amount * amount * amount;
-        },
-        Out (amount) {
-            return --amount * amount * amount * amount * amount + 1;
-        },
-        InOut (amount) {
-            if ((amount *= 2) < 1) {
-                return 0.5 * amount * amount * amount * amount * amount;
-            }
-            return 0.5 * ((amount -= 2) * amount * amount * amount * amount + 2);
+        dracoLoader.manager = manager;
+        dracoLoader.setDecoderPath(dracoPath);
+        let loader = this._loader;
+        if (loader === undefined) {
+            loader = this._loader = new GLTFLoader$1();
+            loader.setDRACOLoader(dracoLoader);
+            loader.setMeshoptDecoder(MeshoptDecoder);
         }
-    }),
-    Sinusoidal: Object.freeze({
-        In (amount) {
-            return 1 - Math.sin((1.0 - amount) * Math.PI / 2);
-        },
-        Out (amount) {
-            return Math.sin(amount * Math.PI / 2);
-        },
-        InOut (amount) {
-            return 0.5 * (1 - Math.sin(Math.PI * (0.5 - amount)));
+        loader.manager = manager;
+        loader.setPath(path);
+        loader.setResourcePath(resourcePath);
+        const loadCallback = (gltf)=>{
+            const node = gltf.scene;
+            node.animations.push(...gltf.animations);
+            onLoad(Loader._setUserData(node));
+        };
+        if (buffer) {
+            loader.parse(buffer, resourcePath, loadCallback, onError);
+        } else {
+            loader.load(url, loadCallback, onProgress, onError);
         }
-    }),
-    Exponential: Object.freeze({
-        In (amount) {
-            return amount === 0 ? 0 : Math.pow(1024, amount - 1);
-        },
-        Out (amount) {
-            return amount === 1 ? 1 : 1 - Math.pow(2, -10 * amount);
-        },
-        InOut (amount) {
-            if (amount === 0) {
-                return 0;
-            }
-            if (amount === 1) {
-                return 1;
-            }
-            if ((amount *= 2) < 1) {
-                return 0.5 * Math.pow(1024, amount - 1);
-            }
-            return 0.5 * (-Math.pow(2, -10 * (amount - 1)) + 2);
+    }
+    constructor(...args){
+        super(...args);
+        this.extension = [
+            "gltf",
+            "glb"
+        ];
+    }
+}
+
+class HDRLoader extends Loader {
+    load({ url, path, resourcePath, manager, texSettings, onLoad, onProgress, onError }) {
+        let loader = this._loader;
+        if (loader === undefined) {
+            loader = this._loader = new RGBELoader();
         }
-    }),
-    Circular: Object.freeze({
-        In (amount) {
-            return 1 - Math.sqrt(1 - amount * amount);
-        },
-        Out (amount) {
-            return Math.sqrt(1 - --amount * amount);
-        },
-        InOut (amount) {
-            if ((amount *= 2) < 1) {
-                return -0.5 * (Math.sqrt(1 - amount * amount) - 1);
-            }
-            return 0.5 * (Math.sqrt(1 - (amount -= 2) * amount) + 1);
-        }
-    }),
-    Elastic: Object.freeze({
-        In (amount) {
-            if (amount === 0) {
-                return 0;
-            }
-            if (amount === 1) {
-                return 1;
-            }
-            return -Math.pow(2, 10 * (amount - 1)) * Math.sin((amount - 1.1) * 5 * Math.PI);
-        },
-        Out (amount) {
-            if (amount === 0) {
-                return 0;
-            }
-            if (amount === 1) {
-                return 1;
-            }
-            return Math.pow(2, -10 * amount) * Math.sin((amount - 0.1) * 5 * Math.PI) + 1;
-        },
-        InOut (amount) {
-            if (amount === 0) {
-                return 0;
-            }
-            if (amount === 1) {
-                return 1;
-            }
-            amount *= 2;
-            if (amount < 1) {
-                return -0.5 * Math.pow(2, 10 * (amount - 1)) * Math.sin((amount - 1.1) * 5 * Math.PI);
-            }
-            return 0.5 * Math.pow(2, -10 * (amount - 1)) * Math.sin((amount - 1.1) * 5 * Math.PI) + 1;
-        }
-    }),
-    Back: Object.freeze({
-        In (amount) {
-            const s = 1.70158;
-            return amount === 1 ? 1 : amount * amount * ((s + 1) * amount - s);
-        },
-        Out (amount) {
-            const s = 1.70158;
-            return amount === 0 ? 0 : --amount * amount * ((s + 1) * amount + s) + 1;
-        },
-        InOut (amount) {
-            const s = 1.70158 * 1.525;
-            if ((amount *= 2) < 1) {
-                return 0.5 * (amount * amount * ((s + 1) * amount - s));
-            }
-            return 0.5 * ((amount -= 2) * amount * ((s + 1) * amount + s) + 2);
-        }
-    }),
-    Bounce: Object.freeze({
-        In (amount) {
-            return 1 - Easing.Bounce.Out(1 - amount);
-        },
-        Out (amount) {
-            if (amount < 1 / 2.75) {
-                return 7.5625 * amount * amount;
-            } else if (amount < 2 / 2.75) {
-                return 7.5625 * (amount -= 1.5 / 2.75) * amount + 0.75;
-            } else if (amount < 2.5 / 2.75) {
-                return 7.5625 * (amount -= 2.25 / 2.75) * amount + 0.9375;
-            } else {
-                return 7.5625 * (amount -= 2.625 / 2.75) * amount + 0.984375;
-            }
-        },
-        InOut (amount) {
-            if (amount < 0.5) {
-                return Easing.Bounce.In(amount * 2) * 0.5;
-            }
-            return Easing.Bounce.Out(amount * 2 - 1) * 0.5 + 0.5;
-        }
-    }),
-    generatePow (power = 4) {
-        power = power < Number.EPSILON ? Number.EPSILON : power;
-        power = power > 10000 ? 10000 : power;
-        return {
-            In (amount) {
-                return amount ** power;
-            },
-            Out (amount) {
-                return 1 - (1 - amount) ** power;
-            },
-            InOut (amount) {
-                if (amount < 0.5) {
-                    return (amount * 2) ** power / 2;
-                }
-                return (1 - (2 - amount * 2) ** power) / 2 + 0.5;
-            }
-        };
-    }
-});
-
-/**
- *
- */ /**
- *
- */ const Interpolation = {
-    Linear: function(v, k) {
-        const m = v.length - 1;
-        const f = m * k;
-        const i = Math.floor(f);
-        const fn = Interpolation.Utils.Linear;
-        if (k < 0) {
-            return fn(v[0], v[1], f);
-        }
-        if (k > 1) {
-            return fn(v[m], v[m - 1], m - f);
-        }
-        return fn(v[i], v[i + 1 > m ? m : i + 1], f - i);
-    },
-    Bezier: function(v, k) {
-        let b = 0;
-        const n = v.length - 1;
-        const pw = Math.pow;
-        const bn = Interpolation.Utils.Bernstein;
-        for(let i = 0; i <= n; i++){
-            b += pw(1 - k, n - i) * pw(k, i) * v[i] * bn(n, i);
-        }
-        return b;
-    },
-    CatmullRom: function(v, k) {
-        const m = v.length - 1;
-        let f = m * k;
-        let i = Math.floor(f);
-        const fn = Interpolation.Utils.CatmullRom;
-        if (v[0] === v[m]) {
-            if (k < 0) {
-                i = Math.floor(f = m * (1 + k));
-            }
-            return fn(v[(i - 1 + m) % m], v[i], v[(i + 1) % m], v[(i + 2) % m], f - i);
-        } else {
-            if (k < 0) {
-                return v[0] - (fn(v[0], v[0], v[1], v[1], -f) - v[0]);
-            }
-            if (k > 1) {
-                return v[m] - (fn(v[m], v[m], v[m - 1], v[m - 1], f - m) - v[m]);
-            }
-            return fn(v[i ? i - 1 : 0], v[i], v[m < i + 1 ? m : i + 1], v[m < i + 2 ? m : i + 2], f - i);
-        }
-    },
-    Utils: {
-        Linear: function(p0, p1, t) {
-            return (p1 - p0) * t + p0;
-        },
-        Bernstein: function(n, i) {
-            const fc = Interpolation.Utils.Factorial;
-            return fc(n) / fc(i) / fc(n - i);
-        },
-        Factorial: function() {
-            const a = [
-                1
-            ];
-            return function(n) {
-                let s = 1;
-                if (a[n]) {
-                    return a[n];
-                }
-                for(let i = n; i > 1; i--){
-                    s *= i;
-                }
-                a[n] = s;
-                return s;
-            };
-        }(),
-        CatmullRom: function(p0, p1, p2, p3, t) {
-            const v0 = (p2 - p0) * 0.5;
-            const v1 = (p3 - p1) * 0.5;
-            const t2 = t * t;
-            const t3 = t * t2;
-            return (2 * p1 - 2 * p2 + v0 + v1) * t3 + (-3 * p1 + 3 * p2 - 2 * v0 - v1) * t2 + v0 * t + p1;
+        loader.manager = manager;
+        loader.setPath(path);
+        loader.setResourcePath(resourcePath);
+        const settings = Object.assign({
+            mapping: EquirectangularReflectionMapping
+        }, texSettings);
+        loader.load(url, (tex)=>onLoad(Object.assign(tex, settings)), onProgress, onError);
+    }
+    constructor(...args){
+        super(...args);
+        this.extension = [
+            "hdr"
+        ];
+    }
+}
+
+class JSONLoader extends Loader {
+    load({ url, path, resourcePath, manager, onLoad, onProgress, onError }) {
+        let loader = this._loader;
+        if (loader === undefined) {
+            loader = this._loader = new FileLoader();
         }
+        loader.manager = manager;
+        loader.setPath(path);
+        loader.setResourcePath(resourcePath);
+        loader.load(url, (file)=>onLoad(JSON.parse(file)), onProgress, onError);
     }
-};
-
-const mainGroup = new TweenGroup();
-
-/**
- * Utils
- */ class Sequence {
-    static nextId() {
-        return Sequence._nextId++;
+    constructor(...args){
+        super(...args);
+        this.extension = [
+            "json"
+        ];
     }
 }
-Sequence._nextId = 0;
 
-class Tween {
-    getId() {
-        return this._id;
-    }
-    getObject() {
-        return this._object;
-    }
-    getGroup() {
-        return this._group;
-    }
-    isPlaying() {
-        return this._isPlaying;
-    }
-    isPaused() {
-        return this._isPaused;
-    }
-    getDuration() {
-        return this._duration;
-    }
-    from(properties) {
-        this._valuesStart = Object.create(properties);
-        return this;
-    }
-    to(target, duration = 1) {
-        if (this._isPlaying) throw new Error('Can not call Tween.to() while Tween is already started or paused. Stop the Tween first.');
-        this._valuesEnd = target;
-        this._propertiesAreSetUp = false;
-        this._duration = duration < 0 ? 0 : duration;
-        return this;
-    }
-    duration(duration = 1) {
-        this._duration = duration < 0 ? 0 : duration;
-        return this;
-    }
-    dynamic(dynamic = false) {
-        this._isDynamic = dynamic;
-        return this;
-    }
-    start(time, overrideStartingValues = false) {
-        if (this._isPlaying) {
-            return this;
-        }
-        // eslint-disable-next-line
-        this._group && this._group.add(this);
-        this._repeat = this._initialRepeat;
-        if (this._reversed) {
-            // If we were reversed (f.e. using the yoyo feature) then we need to
-            // flip the tween direction back to forward.
-            this._reversed = false;
-            for(const property in this._valuesStartRepeat){
-                this._swapEndStartRepeatValues(property);
-                this._valuesStart[property] = this._valuesStartRepeat[property];
-            }
-        }
-        this._isPlaying = true;
-        this._isPaused = false;
-        this._onStartCallbackFired = false;
-        this._onEveryStartCallbackFired = false;
-        this._isChainStopped = false;
-        this._startTime = time;
-        this._startTime += this._delayTime;
-        if (!this._propertiesAreSetUp || overrideStartingValues) {
-            this._propertiesAreSetUp = true;
-            // If dynamic is not enabled, clone the end values instead of using the passed-in end values.
-            if (!this._isDynamic) {
-                const tmp = {};
-                for(const prop in this._valuesEnd)tmp[prop] = this._valuesEnd[prop];
-                this._valuesEnd = tmp;
-            }
-            this._setupProperties(this._object, this._valuesStart, this._valuesEnd, this._valuesStartRepeat, overrideStartingValues);
-        }
-        return this;
-    }
-    startFromCurrentValues(time) {
-        return this.start(time, true);
-    }
-    _setupProperties(_object, _valuesStart, _valuesEnd, _valuesStartRepeat, overrideStartingValues) {
-        for(const property in _valuesEnd){
-            const startValue = _object[property];
-            const startValueIsArray = Array.isArray(startValue);
-            const propType = startValueIsArray ? 'array' : typeof startValue;
-            let isInterpolationList = !startValueIsArray && Array.isArray(_valuesEnd[property]);
-            // If `to()` specifies a property that doesn't exist in the source object,
-            // we should not set that property in the object
-            if (propType === 'undefined' || propType === 'function') {
-                continue;
-            }
-            // Check if an Array was provided as property value
-            if (isInterpolationList) {
-                const endValues = _valuesEnd[property];
-                if (endValues.length === 0) {
-                    continue;
-                }
-                // Handle an array of relative values.
-                // Creates a local copy of the Array with the start value at the front
-                const temp = [
-                    startValue
-                ];
-                for(let i = 0, l = endValues.length; i < l; i += 1){
-                    const value = this._handleRelativeValue(startValue, endValues[i]);
-                    if (isNaN(value)) {
-                        isInterpolationList = false;
-                        console.warn('Found invalid interpolation list. Skipping.');
-                        break;
-                    }
-                    temp.push(value);
-                }
-                if (isInterpolationList) {
-                    // if (_valuesStart[property] === undefined) { // handle end values only the first time. NOT NEEDED? setupProperties is now guarded by _propertiesAreSetUp.
-                    _valuesEnd[property] = temp;
-                // }
-                }
-            }
-            // handle the deepness of the values
-            if ((propType === 'object' || startValueIsArray) && startValue && !isInterpolationList) {
-                _valuesStart[property] = startValueIsArray ? [] : {};
-                const nestedObject = startValue;
-                for(const prop in nestedObject){
-                    _valuesStart[property][prop] = nestedObject[prop];
-                }
-                // TODO? repeat nested values? And yoyo? And array values?
-                _valuesStartRepeat[property] = startValueIsArray ? [] : {};
-                let endValues = _valuesEnd[property];
-                // If dynamic is not enabled, clone the end values instead of using the passed-in end values.
-                if (!this._isDynamic) {
-                    const tmp = {};
-                    for(const prop in endValues)tmp[prop] = endValues[prop];
-                    _valuesEnd[property] = endValues = tmp;
-                }
-                this._setupProperties(nestedObject, _valuesStart[property], endValues, _valuesStartRepeat[property], overrideStartingValues);
-            } else {
-                // Save the starting value, but only once unless override is requested.
-                if (typeof _valuesStart[property] === 'undefined' || overrideStartingValues) {
-                    _valuesStart[property] = startValue;
-                }
-                if (!startValueIsArray) {
-                    // eslint-disable-next-line
-                    // @ts-ignore FIXME?
-                    _valuesStart[property] *= 1.0 // Ensures we're using numbers, not strings
-                    ;
-                }
-                if (isInterpolationList) {
-                    // eslint-disable-next-line
-                    // @ts-ignore FIXME?
-                    _valuesStartRepeat[property] = _valuesEnd[property].slice().reverse();
-                } else {
-                    _valuesStartRepeat[property] = _valuesStart[property] || 0;
-                }
-            }
-        }
-    }
-    stop() {
-        if (!this._isChainStopped) {
-            this._isChainStopped = true;
-            this.stopChainedTweens();
-        }
-        if (!this._isPlaying) {
-            return this;
-        }
-        // eslint-disable-next-line
-        this._group && this._group.remove(this);
-        this._isPlaying = false;
-        this._isPaused = false;
-        if (this._onStopCallback) {
-            this._onStopCallback(this._object);
+class TextureLoader extends Loader {
+    load({ url, path, resourcePath, manager, texSettings, onLoad, onProgress, onError }) {
+        let loader = this._loader;
+        if (loader === undefined) {
+            loader = this._loader = new TextureLoader$1();
         }
-        return this;
+        loader.manager = manager;
+        loader.setPath(path);
+        loader.setResourcePath(resourcePath);
+        const loadCallback = (tex)=>{
+            tex.colorSpace = SRGBColorSpace;
+            onLoad(Object.assign(tex, texSettings));
+        };
+        loader.load(url, loadCallback, onProgress, onError);
     }
-    end() {
-        this._goToEnd = true;
-        this.update(Infinity);
-        return this;
+    constructor(...args){
+        super(...args);
+        this.extension = [
+            "png",
+            "jpg",
+            "webp",
+            "avif"
+        ];
     }
-    pause(time) {
-        if (this._isPaused || !this._isPlaying) {
-            return this;
+}
+
+class BINLoader extends Loader {
+    load({ url, buffer, path, resourcePath, dracoPath, manager, onLoad, onProgress, onError }) {
+        let dracoLoader = this._dracoLoader;
+        if (dracoLoader === undefined) {
+            dracoLoader = this._dracoLoader = new DRACOLoader();
         }
-        this._isPaused = true;
-        this._pauseStart = time;
-        // eslint-disable-next-line
-        this._group && this._group.remove(this);
-        return this;
-    }
-    resume(time) {
-        if (!this._isPaused || !this._isPlaying) {
-            return this;
+        dracoLoader.manager = manager;
+        dracoLoader.setDecoderPath(dracoPath);
+        let loader = this._loader;
+        if (loader === undefined) {
+            loader = this._loader = new CustomLoader();
+            loader.setDRACOLoader(dracoLoader);
+            loader.setMeshoptDecoder(MeshoptDecoder);
         }
-        this._isPaused = false;
-        this._startTime += time - this._pauseStart;
-        this._pauseStart = 0;
-        // eslint-disable-next-line
-        this._group && this._group.add(this);
-        return this;
-    }
-    stopChainedTweens() {
-        for(let i = 0, numChainedTweens = this._chainedTweens.length; i < numChainedTweens; i++){
-            this._chainedTweens[i].stop();
+        loader.salt = this.salt;
+        loader.manager = manager;
+        loader.setPath(path);
+        loader.setResourcePath(resourcePath);
+        const loadCallback = (gltf)=>{
+            const node = gltf.scene;
+            node.animations.push(...gltf.animations);
+            onLoad(Loader._setUserData(node));
+        };
+        if (buffer) {
+            loader.parse(buffer, resourcePath, loadCallback, onError);
+        } else {
+            loader.load(url, loadCallback, onProgress, onError);
         }
-        return this;
-    }
-    group(group = mainGroup) {
-        this._group = group;
-        return this;
-    }
-    call(callback) {
-        this._onFinishCallback = callback;
-        return this;
-    }
-    delay(amount = 0) {
-        this._delayTime = amount;
-        return this;
-    }
-    union(headTween, tailTween) {
-        this._headTween = headTween;
-        this._tailTween = tailTween.chain(this);
-        return this;
-    }
-    repeat(times = 0) {
-        this._initialRepeat = times;
-        this._repeat = times;
-        return this;
-    }
-    repeatDelay(amount) {
-        this._repeatDelayTime = amount;
-        return this;
-    }
-    yoyo(yoyo = false) {
-        this._yoyo = yoyo;
-        return this;
-    }
-    easing(easingFunction = Easing.Linear.None) {
-        this._easingFunction = easingFunction;
-        return this;
-    }
-    interpolation(interpolationFunction = Interpolation.Linear) {
-        this._interpolationFunction = interpolationFunction;
-        return this;
-    }
-    // eslint-disable-next-line
-    chain(...tweens) {
-        this._chainedTweens = tweens;
-        return this;
-    }
-    unchain(...tweens) {
-        tweens.forEach((tween)=>{
-            let index = this._chainedTweens.findIndex((v)=>v === tween);
-            if (index > -1) this._chainedTweens.splice(index, 1);
-        });
-        return this;
-    }
-    onStart(callback) {
-        this._onStartCallback = callback;
-        return this;
     }
-    onEveryStart(callback) {
-        this._onEveryStartCallback = callback;
-        return this;
-    }
-    onUpdate(callback) {
-        this._onUpdateCallback = callback;
-        return this;
+    constructor(...args){
+        super(...args);
+        this.extension = [
+            "bin"
+        ];
+        this.salt = 255;
     }
-    onRepeat(callback) {
-        this._onRepeatCallback = callback;
-        return this;
+}
+class CustomLoader extends GLTFLoader$1 {
+    parse(data, path, onLoad, onError) {
+        super.parse(glbDecode(data, this.salt), path, onLoad, onError);
     }
-    onComplete(callback) {
-        this._onCompleteCallback = callback;
-        return this;
+    constructor(...args){
+        super(...args);
+        this.salt = 255;
     }
-    onStop(callback) {
-        this._onStopCallback = callback;
-        return this;
+}
+const BINARY_EXTENSION_HEADER_MAGIC = 'glTF';
+const BINARY_EXTENSION_HEADER_LENGTH = 12;
+function encryptArray(array, salt) {
+    for(let i = 0, n = array.length; i < n; i++){
+        array[i] ^= salt;
     }
-    /**
-	 * @returns true if the tween is still playing after the update, false
-	 * otherwise (calling update on a paused tween still returns true because
-	 * it is still playing, just paused).
-	 */ update(time, autoStart = true) {
-        if (this._isPaused) return true;
-        const endTime = this._startTime + this._duration;
-        if (!this._goToEnd && !this._isPlaying) {
-            if (time > endTime) return false;
-            if (autoStart) this.start(time, true);
-        }
-        this._goToEnd = false;
-        if (time < this._startTime) {
-            return true;
-        }
-        if (this._onStartCallbackFired === false) {
-            if (this._onStartCallback) {
-                this._onStartCallback(this._object);
-            }
-            this._onStartCallbackFired = true;
-        }
-        if (this._onEveryStartCallbackFired === false) {
-            if (this._onEveryStartCallback) {
-                this._onEveryStartCallback(this._object);
-            }
-            this._onEveryStartCallbackFired = true;
-        }
-        const elapsedTime = time - this._startTime;
-        var _this__repeatDelayTime;
-        const durationAndDelay = this._duration + ((_this__repeatDelayTime = this._repeatDelayTime) != null ? _this__repeatDelayTime : this._delayTime);
-        const totalTime = this._duration + this._repeat * durationAndDelay;
-        const elapsed = this._calculateElapsedPortion(elapsedTime, durationAndDelay, totalTime);
-        const value = this._easingFunction(elapsed);
-        if (elapsed === 1) {
-            if (this._onFinishCallback) {
-                this._onFinishCallback(this._object);
-            }
-            if (this._headTween) {
-                if (this._headTweenStartFired === false) {
-                    this._headTweenStartFired = true;
-                    this._headTween.start(this._startTime + this._duration);
-                    this._isPlaying = false;
-                    return false;
-                }
-            }
-        }
-        const status = this._calculateCompletionStatus(elapsedTime, durationAndDelay);
-        if (status === 'repeat') {
-            // the current update is happening after the instant the tween repeated
-            this._processRepetition(elapsedTime, durationAndDelay);
-        }
-        this._updateProperties(this._object, this._valuesStart, this._valuesEnd, value);
-        if (status === 'about-to-repeat') {
-            // the current update is happening at the exact instant the tween is going to repeat
-            // the values should match the end of the tween, not the beginning,
-            // that's why _processRepetition happens after _updateProperties
-            this._processRepetition(elapsedTime, durationAndDelay);
-        }
-        if (this._onUpdateCallback) {
-            this._onUpdateCallback(this._object, elapsed);
-        }
-        if (status === 'repeat' || status === 'about-to-repeat') {
-            if (this._onRepeatCallback) {
-                this._onRepeatCallback(this._object);
-            }
-            if (this._headTween) {
-                this._headTweenStartFired = false;
-                this._initialRepeat = this._repeat;
-            }
-            this._onEveryStartCallbackFired = false;
-        } else if (status === 'completed') {
-            this._isPlaying = false;
-            if (this._tailTween) {
-                this._tailTween.unchain(this);
-            }
-            if (this._onCompleteCallback) {
-                this._onCompleteCallback(this._object);
-            }
-            for(let i = 0, numChainedTweens = this._chainedTweens.length; i < numChainedTweens; i++){
-                // Make the chained tweens start exactly at the time they should,
-                // even if the `update()` method was called way past the duration of the tween
-                this._chainedTweens[i].start(this._startTime + this._duration, false);
-            }
-        }
-        return status !== 'completed';
-    }
-    _calculateElapsedPortion(elapsedTime, durationAndDelay, totalTime) {
-        if (this._duration === 0 || elapsedTime > totalTime) {
-            return 1;
-        }
-        const timeIntoCurrentRepeat = elapsedTime % durationAndDelay;
-        const portion = Math.min(timeIntoCurrentRepeat / this._duration, 1);
-        if (portion === 0 && elapsedTime !== 0 && elapsedTime % this._duration === 0) {
-            return 1;
-        }
-        return portion;
-    }
-    _calculateCompletionStatus(elapsedTime, durationAndDelay) {
-        if (this._duration !== 0 && elapsedTime < this._duration) {
-            return 'playing';
-        }
-        if (this._repeat <= 0) {
-            return 'completed';
-        }
-        if (elapsedTime === this._duration) {
-            return 'about-to-repeat';
-        }
-        return 'repeat';
+    return array;
+}
+function glbDecode(buffer, salt = 255) {
+    encryptArray(new Uint8Array(buffer, 0, 4), salt);
+    const headerView = new DataView(buffer, 0, BINARY_EXTENSION_HEADER_LENGTH);
+    const textDecoder = new TextDecoder();
+    const header = {
+        magic: textDecoder.decode(new Uint8Array(buffer.slice(0, 4))),
+        version: headerView.getUint32(4, true),
+        length: headerView.getUint32(8, true)
+    };
+    if (header.magic !== BINARY_EXTENSION_HEADER_MAGIC) {
+        throw new Error('Unsupported glTF-Binary header.');
+    } else if (header.version < 2.0) {
+        throw new Error('Legacy binary file detected.');
+    }
+    const chunkContentsLength = header.length - BINARY_EXTENSION_HEADER_LENGTH;
+    const chunkView = new DataView(buffer, BINARY_EXTENSION_HEADER_LENGTH);
+    let chunkIndex = 0;
+    while(chunkIndex < chunkContentsLength){
+        const chunkLength = chunkView.getUint32(chunkIndex, true);
+        chunkIndex += 4;
+        encryptArray(new Uint8Array(buffer, BINARY_EXTENSION_HEADER_LENGTH + chunkIndex, chunkLength + 4), salt);
+        chunkIndex += 4;
+        chunkIndex += chunkLength;
+    }
+    return buffer;
+}
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol */
+
+
+function __decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+  var e = new Error(message);
+  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+const { clamp: clamp$4 } = MathUtils;
+const { min, max: max$1, exp } = Math;
+const kNegligibleResidual = 0.01;
+const kLogNegligibleResidual = Math.log(kNegligibleResidual) // -4.605170186;
+;
+function exponentialDamp(current, target, dampTime, deltaTime) {
+    let k = -kLogNegligibleResidual / dampTime;
+    return current + (target - current) * (1 - exp(-k * deltaTime));
+}
+// cuve like exponentialDecay but cost less
+function quarticDamp(current, target, dampTime, deltaTime) {
+    let t = 1 - min(deltaTime, dampTime) / dampTime;
+    let tt = t * t;
+    return current + (target - current) * (1 - tt * tt);
+}
+function smoothDamp(state, current, target, smoothTime, maxSpeed, deltaTime) {
+    if (state._velocity === undefined) {
+        state._velocity = 0;
     }
-    _processRepetition(elapsedTime, durationAndDelay) {
-        const completeCount = Math.min(durationAndDelay > 0 ? Math.trunc((elapsedTime - this._duration) / durationAndDelay) + 1 : 1, this._repeat);
-        if (isFinite(this._repeat)) {
-            this._repeat -= completeCount;
-        }
-        // Reassign starting values, restart by making startTime = now
-        for(const property in this._valuesStartRepeat){
-            const valueEnd = this._valuesEnd[property];
-            if (!this._yoyo && typeof valueEnd === 'string') {
-                this._valuesStartRepeat[property] = this._valuesStartRepeat[property] + parseFloat(valueEnd);
-            }
-            if (this._yoyo) {
-                this._swapEndStartRepeatValues(property);
-            }
-            this._valuesStart[property] = this._valuesStartRepeat[property];
-        }
-        if (this._yoyo) {
-            this._reversed = !this._reversed;
-        }
-        this._startTime += durationAndDelay * completeCount;
+    smoothTime = max$1(0.0001, smoothTime);
+    let num = 2 / smoothTime;
+    let num2 = num * deltaTime;
+    let num3 = 1 / (1 + num2 + 0.48 * num2 * num2 + 0.235 * num2 * num2 * num2);
+    let num4 = current - target;
+    let num5 = target;
+    let num6 = maxSpeed * smoothTime;
+    num4 = clamp$4(num4, -num6, num6);
+    target = current - num4;
+    let num7 = (state._velocity + num * num4) * deltaTime;
+    state._velocity = (state._velocity - num * num7) * num3;
+    let num8 = target + (num4 + num7) * num3;
+    if (num5 - current > 0 == num8 > num5) {
+        num8 = num5;
+        state._velocity = (num8 - num5) / deltaTime;
     }
-    _updateProperties(_object, _valuesStart, _valuesEnd, value) {
-        for(const property in _valuesEnd){
-            // Don't update properties that do not exist in the source object
-            if (_valuesStart[property] === undefined) {
-                continue;
-            }
-            const start = _valuesStart[property] || 0;
-            let end = _valuesEnd[property];
-            const startIsArray = Array.isArray(_object[property]);
-            const endIsArray = Array.isArray(end);
-            const isInterpolationList = !startIsArray && endIsArray;
-            if (isInterpolationList) {
-                _object[property] = this._interpolationFunction(end, value);
-            } else if (typeof end === 'object' && end) {
-                // eslint-disable-next-line
-                // @ts-ignore FIXME?
-                let des = getPropertyDescriptor(_object, property);
-                if ((des == null ? void 0 : des.set) || (des == null ? void 0 : des.writable)) {
-                    _object[property] = this._updateProperties(_object[property], start, end, value);
-                } else {
-                    this._updateProperties(_object[property], start, end, value);
-                }
-            } else {
-                // Parses relative end values with start as base (e.g.: +10, -3)
-                end = this._handleRelativeValue(start, end);
-                // Protect against non numeric properties.
-                if (typeof end === 'number') {
-                    // eslint-disable-next-line
-                    // @ts-ignore FIXME?
-                    _object[property] = start + (end - start) * value;
-                }
-            }
-        }
-        return _object;
+    return num8;
+}
+function Quat_exponentialDamp(current, target, dampTime, deltaTime, out = current) {
+    return out.copy(current).slerp(target, exponentialDamp(0, 1, dampTime, deltaTime));
+}
+function Quat_quarticDamp(current, target, dampTime, deltaTime, out = current) {
+    return out.copy(current).slerp(target, quarticDamp(0, 1, dampTime, deltaTime));
+}
+function Quat_smoothDamp(current, target, dampTime, deltaTime, out = current) {
+    return out.copy(current).slerp(target, smoothDamp(out, 0, 1, dampTime, Infinity, deltaTime));
+}
+function Vec3_smoothDamp(current, target, dampTime, deltaTime, out = current) {
+    return out.copy(current).lerp(target, smoothDamp(out, 0, 1, dampTime, Infinity, deltaTime));
+}
+
+const Vector3_UNIT_X = Object.freeze(new Vector3(1, 0, 0));
+const Vector3_UNIT_Y = Object.freeze(new Vector3(0, 1, 0));
+const Vector3_UNIT_Z = Object.freeze(new Vector3(0, 0, 1));
+const Vector3_RIGHT = Object.freeze(new Vector3(1, 0, 0));
+const Vector3_UP = Object.freeze(new Vector3(0, 1, 0));
+const Vector3_ZERO = Object.freeze(new Vector3(0, 0, 0));
+const Vector3_ONE = Object.freeze(new Vector3(1, 1, 1));
+const Vector3_NEG_ONE = Object.freeze(new Vector3(-1, -1, -1));
+
+const { clamp: clamp$3 } = MathUtils;
+const { max, abs: abs$1, acos } = Math;
+const EPSILON = 1.e-6;
+const __deltaMap = new Map();
+__deltaMap.set(Vector3, new Vector3());
+__deltaMap.set(Vector2, new Vector2());
+function VInterpTo(current, target, deltaTime, speed, out = current, epsilon = EPSILON) {
+    if (speed <= 0) {
+        return out.copy(target);
     }
-    _handleRelativeValue(start, end) {
-        if (typeof end !== 'string') {
-            return end;
-        }
-        if (end.charAt(0) === '+' || end.charAt(0) === '-') {
-            return start + parseFloat(end);
-        }
-        return parseFloat(end);
+    let dist = __deltaMap.get(current.constructor).copy(target).sub(current);
+    if (dist.lengthSq() < epsilon) {
+        return out.copy(target);
     }
-    _swapEndStartRepeatValues(property) {
-        const tmp = this._valuesStartRepeat[property];
-        const endValue = this._valuesEnd[property];
-        if (typeof endValue === 'string') {
-            this._valuesStartRepeat[property] = this._valuesStartRepeat[property] + parseFloat(endValue);
+    return out.copy(current).add(dist.multiplyScalar(clamp$3(deltaTime * speed, 0, 1)));
+}
+function VInterpConstantTo(current, target, deltaTime, speed, out = current) {
+    let delta = __deltaMap.get(current.constructor).copy(target).sub(current);
+    let deltaM = delta.length();
+    let maxStep = speed * deltaTime;
+    if (deltaM > maxStep) {
+        if (maxStep > 0) {
+            let deltaN = delta.multiplyScalar(1 / deltaM);
+            return out.copy(current).add(deltaN);
         } else {
-            this._valuesStartRepeat[property] = this._valuesEnd[property];
-        }
-        this._valuesEnd[property] = tmp;
-    }
-    constructor(_object, _group = mainGroup){
-        this._object = _object;
-        this._group = _group;
-        this._isPaused = false;
-        this._pauseStart = 0;
-        this._valuesStart = {};
-        this._valuesEnd = {};
-        this._valuesStartRepeat = {};
-        this._duration = 0;
-        this._isDynamic = false;
-        this._initialRepeat = 0;
-        this._repeat = 0;
-        this._yoyo = false;
-        this._isPlaying = false;
-        this._reversed = false;
-        this._delayTime = 0;
-        this._startTime = 0;
-        this._easingFunction = Easing.Linear.None;
-        this._interpolationFunction = Interpolation.Linear;
-        this._chainedTweens = [];
-        this._onStartCallbackFired = false;
-        this._onEveryStartCallbackFired = false;
-        this._id = Sequence.nextId();
-        this._isChainStopped = false;
-        this._propertiesAreSetUp = false;
-        this._headTween = null;
-        this._tailTween = null;
-        this._headTweenStartFired = false;
-        this._goToEnd = false;
+            return out.copy(current);
+        }
     }
+    return out.copy(target);
 }
-function getPropertyDescriptor(obj, prop) {
-    while(obj){
-        let desc = Object.getOwnPropertyDescriptor(obj, prop);
-        if (desc) return desc;
-        obj = Object.getPrototypeOf(obj);
-    }
-    return undefined;
+function Quat_Equals(a, b, epsilon = EPSILON) {
+    return abs$1(a.x - b.x) <= epsilon * max(1., abs$1(a.x), abs$1(b.x)) && abs$1(a.y - b.y) <= epsilon * max(1., abs$1(a.y), abs$1(b.y)) && abs$1(a.z - b.z) <= epsilon * max(1., abs$1(a.z), abs$1(b.z)) && abs$1(a.w - b.w) <= epsilon * max(1., abs$1(a.w), abs$1(b.w));
 }
-
-class TweenChain {
-    start() {
-        if (this._group) {
-            this._group.removeOf(this._obj);
-        }
-        this._tween.start(now());
-        return this;
+function Quat_AngularDistance(a, b) {
+    let innerProd = a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
+    return acos(2 * innerProd * innerProd - 1);
+}
+function QInterpTo(current, target, deltaTime, speed, epsilon = EPSILON) {
+    if (speed <= 0) {
+        return target;
     }
-    pause() {
-        this._tween.pause(now());
-        return this;
+    if (Quat_Equals(current, target, epsilon)) {
+        return target;
     }
-    stop() {
-        this._tween.stop();
-        return this;
+    return current.slerp(target, clamp$3(speed * deltaTime, 0, 1));
+}
+function QInterpConstantTo(current, target, deltaTime, speed, out = current) {
+    if (speed <= 0) {
+        return out.copy(target);
     }
-    repeat(times) {
-        this._chainedTween.repeat(times);
-        return this;
+    if (Quat_Equals(current, target)) {
+        return out.copy(target);
     }
-    union() {
-        this._chainedTween = this._tween = new Tween(this._obj, this._group).union(this._tween, this._chainedTween);
-        return this;
+    let deltaSpeed = clamp$3(speed * deltaTime, 0, 1);
+    let angularDist = max(Quat_AngularDistance(current, target), EPSILON);
+    return out.copy(current).slerp(target, clamp$3(deltaSpeed / angularDist, 0, 1));
+}
+//非线性
+function FInterpTo(current, target, deltaTime, speed, epsilon = EPSILON) {
+    if (speed <= 0) {
+        return target;
     }
-    call(callback) {
-        this._chainTween().call(callback);
-        return this;
+    let dist = target - current;
+    if (abs$1(dist) < epsilon) {
+        return target;
     }
-    delay(amount) {
-        this._chainTween().delay(amount);
-        return this;
+    return current + dist * clamp$3(speed * deltaTime, 0, 1);
+}
+//线性插值
+function FInterpConstantTo(current, target, deltaTime, speed, epsilon = EPSILON) {
+    let dist = target - current;
+    if (abs$1(dist) < epsilon) {
+        return target;
     }
-    to(properties, duration, props) {
-        let tween = this._chainTween().to(properties, duration);
-        if (props) {
-            if (props.from) tween.from(props.from);
-            if (props.easing) tween.easing(props.easing);
-            if (props.onStart) tween.onStart(props.onStart);
-            if (props.onStop) tween.onStop(props.onStop);
-            if (props.onComplete) tween.onComplete(props.onComplete);
-            if (props.onUpdate) tween.onUpdate(props.onUpdate);
-            if (props.onRepeat) tween.onRepeat(props.onRepeat);
-        }
+    let step = speed * deltaTime;
+    return current + clamp$3(dist, -step, step);
+}
+
+const { lerp: lerp$1, clamp: clamp$2 } = MathUtils;
+function catmullRom(t, p0, p1, p2, p3) {
+    const v0 = (p2 - p0) * 0.5;
+    const v1 = (p3 - p1) * 0.5;
+    const t2 = t * t;
+    const t3 = t * t2;
+    return (2 * p1 - 2 * p2 + v0 + v1) * t3 + (-3 * p1 + 3 * p2 - 2 * v0 - v1) * t2 + v0 * t + p1;
+}
+class CurvePoint {
+    set(x, y) {
+        this.x = x;
+        this.y = y;
         return this;
     }
-    _chainTween() {
-        let tween = this._tween;
-        if (this._chainedTween) {
-            tween = new Tween(this._obj, this._group);
-            this._chainedTween.chain(tween);
-        }
-        this._chainedTween = tween;
-        return tween;
+    lerp(p, t, out = this) {
+        out.x = lerp$1(this.x, p.x, t);
+        out.y = lerp$1(this.y, p.y, t);
+        return out;
     }
-    constructor(object, group){
-        this._obj = object;
-        this._group = group;
-        this._tween = new Tween(object, group);
+    constructor(x = 0, y = 0, mode = 0){
+        this.x = x;
+        this.y = y;
+        this.mode = mode;
     }
 }
-
-class TweenManager {
-    update(dt) {
-        this._group.update(now());
+class AnimationCurve {
+    _getInterpolant(samples) {
+        if (this._samples !== samples) {
+            this._samples = samples;
+            this._interpolant = new LinearInterpolant(new Float32Array(samples), new Float32Array(samples), 1, new Float32Array(samples));
+        }
+        return this._interpolant;
     }
-    timeline(target) {
-        return new TweenChain(target, this._group);
+    createCurvePoint(x, y, mode) {
+        return new CurvePoint(x, y, mode);
     }
-    killAll() {
-        this._group.removeAll();
+    resample(samples = 100) {
+        const step = 1 / (samples - 1);
+        const interpolant = this._getInterpolant(samples);
+        const times = interpolant.parameterPositions;
+        const values = interpolant.sampleValues;
+        const point = this.createCurvePoint();
+        for(let i = 0; i < samples; i++){
+            this.getPoint(i * step, point);
+            times[i] = point.x;
+            values[i] = point.y;
+        }
     }
-    killOf(target) {
-        this._group.removeOf(target);
+    evaluate(t) {
+        if (this.needsUpdate) {
+            this.needsUpdate = false;
+            this.resample();
+        }
+        return this._interpolant.evaluate(t)[0];
     }
-    constructor(){
-        this._group = new TweenGroup();
+    getPoint(t, out) {
+        const points = this.points;
+        if (t <= 0) {
+            return out.set(t, points[0].y);
+        }
+        if (t >= 1) {
+            return out.set(t, points[points.length - 1].y);
+        }
+        const p = (points.length - 1) * t;
+        const intPoint = Math.floor(p);
+        const weight = p - intPoint;
+        const p0 = points[intPoint === 0 ? intPoint : intPoint - 1];
+        const p1 = points[intPoint];
+        const p2 = points[intPoint > points.length - 2 ? points.length - 1 : intPoint + 1];
+        const p3 = points[intPoint > points.length - 3 ? points.length - 1 : intPoint + 2];
+        if (p1.mode === 1 || p0 === p1 && p2.mode === 1) {
+            return p1.lerp(p2, weight, out);
+        }
+        return out.set(clamp$2(catmullRom(weight, p0.x, p1.x, p2.x, p3.x), 0, 1), clamp$2(catmullRom(weight, p0.y, p1.y, p2.y, p3.y), 0, 1));
     }
-}
-
-class aLoader {
-    static _setUserData(node) {
-        const keys = aLoader._texKeys;
-        const meshes = [];
-        const textures = {};
-        const materials = {};
-        const queue = [
-            node
-        ];
-        while(queue.length !== 0){
-            let object = queue.shift();
-            if (object.isMesh) {
-                meshes.push(object);
-                const mat = object.material;
-                if (Array.isArray(mat)) mat.forEach((v)=>materials[v.uuid] = v);
-                else materials[mat.uuid] = mat;
-            }
-            queue.push(...object.children);
-        }
-        Object.values(materials).forEach((mat)=>{
-            keys.forEach((k)=>{
-                let tex = mat[k];
-                if (tex) {
-                    textures[tex.uuid] = tex;
-                }
-            });
-        });
-        Object.assign(node.userData, {
-            meshes,
-            materials,
-            textures
-        });
-        return node;
-    }
-    constructor(manager){
-        this.manager = manager;
-    }
-}
-aLoader._texKeys = [
-    "map",
-    "alphaMap",
-    "aoMap",
-    "bumpMap",
-    "displacementMap",
-    "emissiveMap",
-    "envMap",
-    "lightMap",
-    "metalnessMap",
-    "normalMap",
-    "roughnessMap",
-    "specularMap",
-    "alphaMap"
-];
-
-class aEXRLoader extends aLoader {
-    load({ url, path, resourcePath, manager, texSettings, onLoad, onProgress, onError }) {
-        let loader = this._loader;
-        if (loader === undefined) {
-            loader = this._loader = new EXRLoader();
-        }
-        loader.manager = manager;
-        loader.setPath(path);
-        loader.setResourcePath(resourcePath);
-        loader.load(url, (tex)=>onLoad(Object.assign(tex, texSettings)), onProgress, onError);
-    }
-    constructor(...args){
-        super(...args);
-        this.extension = [
-            "exr"
-        ];
+    constructor(name = "", points = [
+        new CurvePoint(0, 0),
+        new CurvePoint(1, 1)
+    ]){
+        this.name = name;
+        this.points = points;
+        this.needsUpdate = true;
+        this.isAnimationCurve = true;
+        this._samples = 100;
+        this._interpolant = new LinearInterpolant(new Float32Array(100), new Float32Array(100), 1, new Float32Array(100));
     }
 }
 
-class aFBXLoader extends aLoader {
-    load({ url, buffer, path, resourcePath, manager, onLoad, onProgress, onError }) {
-        let loader = this._loader;
-        if (loader === undefined) {
-            loader = this._loader = new FBXLoader();
-        }
-        loader.manager = manager;
-        loader.setPath(path);
-        loader.setResourcePath(resourcePath);
-        const loadCallback = (node)=>{
-            onLoad(aLoader._setUserData(node));
-        };
-        if (buffer) {
-            loadCallback(loader.parse(buffer, resourcePath));
+const { floor } = Math;
+// Copyright (C) 2016 Keijiro Takahashi
+// https://mrl.cs.nyu.edu/~perlin/noise/
+class Perlin {
+    static Noise(x, y, z) {
+        let fade = Perlin._Fade;
+        let grad = Perlin._Grad;
+        let lerp = Perlin._Lerp;
+        let p = Perlin._Permutation;
+        if (y !== undefined && z !== undefined) {
+            let xi = floor(x);
+            let yi = floor(y);
+            let zi = floor(z);
+            let X = xi & 0xff; // FIND UNIT CUBE THAT
+            let Y = yi & 0xff; // CONTAINS POINT.
+            let Z = zi & 0xff;
+            x -= xi; // FIND RELATIVE X,Y,Z
+            y -= yi; // OF POINT IN CUBE.
+            z -= zi;
+            let u = fade(x); // COMPUTE FADE CURVES
+            let v = fade(y); // FOR EACH OF X,Y,Z.
+            let w = fade(z);
+            let A = p[X] + Y, AA = p[A] + Z, AB = p[A + 1] + Z; // HASH COORDINATES OF
+            let B = p[X + 1] + Y, BA = p[B] + Z, BB = p[B + 1] + Z; // THE 8 CUBE CORNERS,
+            return lerp(w, lerp(v, lerp(u, grad(p[AA], x, y, z), grad(p[BA], x - 1, y, z)), lerp(u, grad(p[AB], x, y - 1, z), grad(p[BB], x - 1, y - 1, z))), lerp(v, lerp(u, grad(p[AA + 1], x, y, z - 1), grad(p[BA + 1], x - 1, y, z - 1)), lerp(u, grad(p[AB + 1], x, y - 1, z - 1), grad(p[BB + 1], x - 1, y - 1, z - 1))));
+        } else if (y !== undefined) {
+            let xi = floor(x);
+            let yi = floor(y);
+            let X = xi & 0xff;
+            let Y = yi & 0xff;
+            x -= xi;
+            y -= yi;
+            let u = fade(x);
+            let v = fade(y);
+            let A = p[X] + Y & 0xff;
+            let B = p[X + 1] + Y & 0xff;
+            return lerp(v, lerp(u, grad(p[A], x, y), grad(p[B], x - 1, y)), lerp(u, grad(p[A + 1], x, y - 1), grad(p[B + 1], x - 1, y - 1)));
         } else {
-            loader.load(url, loadCallback, onProgress, onError);
+            let xi = floor(x);
+            let X = xi & 0xff;
+            x -= xi;
+            let u = fade(x);
+            return lerp(u, grad(p[X], x), grad(p[X + 1], x - 1));
         }
     }
-    constructor(...args){
-        super(...args);
-        this.extension = [
-            "fbx"
-        ];
-    }
-}
-
-class aGLTFLoader extends aLoader {
-    load({ url, buffer, path, resourcePath, dracoPath, manager, onLoad, onProgress, onError }) {
-        let dracoLoader = this._dracoLoader;
-        if (dracoLoader === undefined) {
-            dracoLoader = this._dracoLoader = new DRACOLoader();
-        }
-        dracoLoader.manager = manager;
-        dracoLoader.setDecoderPath(dracoPath);
-        let loader = this._loader;
-        if (loader === undefined) {
-            loader = this._loader = new GLTFLoader();
-            loader.setDRACOLoader(dracoLoader);
-            loader.setMeshoptDecoder(MeshoptDecoder);
-        }
-        loader.manager = manager;
-        loader.setPath(path);
-        loader.setResourcePath(resourcePath);
-        const loadCallback = (gltf)=>{
-            const node = gltf.scene;
-            node.animations.push(...gltf.animations);
-            onLoad(aLoader._setUserData(node));
-        };
-        if (buffer) {
-            loader.parse(buffer, resourcePath, loadCallback, onError);
+    static Fbm(octave, x, y, z) {
+        let f = 0;
+        let w = 0.5;
+        let noise = Perlin.Noise;
+        if (y !== undefined && z !== undefined) {
+            for(let i = 0; i < octave; i++){
+                f += w * noise(x, y, z);
+                x *= 2.0;
+                y *= 2.0;
+                z *= 2.0;
+                w *= 0.5;
+            }
+        } else if (y !== undefined) {
+            for(let i = 0; i < octave; i++){
+                f += w * noise(x, y);
+                x *= 2.0;
+                y *= 2.0;
+                w *= 0.5;
+            }
         } else {
-            loader.load(url, loadCallback, onProgress, onError);
+            for(let i = 0; i < octave; i++){
+                f += w * noise(x);
+                x *= 2.0;
+                w *= 0.5;
+            }
         }
+        return f;
     }
-    constructor(...args){
-        super(...args);
-        this.extension = [
-            "gltf",
-            "glb"
-        ];
-    }
-}
-
-class aHDRLoader extends aLoader {
-    load({ url, path, resourcePath, manager, texSettings, onLoad, onProgress, onError }) {
-        let loader = this._loader;
-        if (loader === undefined) {
-            loader = this._loader = new RGBELoader();
-        }
-        loader.manager = manager;
-        loader.setPath(path);
-        loader.setResourcePath(resourcePath);
-        const settings = Object.assign({
-            mapping: EquirectangularReflectionMapping
-        }, texSettings);
-        loader.load(url, (tex)=>onLoad(Object.assign(tex, settings)), onProgress, onError);
+    static _Fade(t) {
+        return t * t * t * (t * (t * 6 - 15) + 10);
     }
-    constructor(...args){
-        super(...args);
-        this.extension = [
-            "hdr"
-        ];
+    static _Lerp(t, a, b) {
+        return a + t * (b - a);
     }
-}
-
-class aJSONLoader extends aLoader {
-    load({ url, path, resourcePath, manager, onLoad, onProgress, onError }) {
-        let loader = this._loader;
-        if (loader === undefined) {
-            loader = this._loader = new FileLoader();
-        }
-        loader.manager = manager;
-        loader.setPath(path);
-        loader.setResourcePath(resourcePath);
-        loader.load(url, (file)=>onLoad(JSON.parse(file)), onProgress, onError);
-    }
-    constructor(...args){
-        super(...args);
-        this.extension = [
-            "json"
-        ];
-    }
-}
-
-class aTextureLoader extends aLoader {
-    load({ url, path, resourcePath, manager, texSettings, onLoad, onProgress, onError }) {
-        let loader = this._loader;
-        if (loader === undefined) {
-            loader = this._loader = new TextureLoader();
-        }
-        loader.manager = manager;
-        loader.setPath(path);
-        loader.setResourcePath(resourcePath);
-        const loadCallback = (tex)=>{
-            tex.colorSpace = SRGBColorSpace;
-            onLoad(Object.assign(tex, texSettings));
-        };
-        loader.load(url, loadCallback, onProgress, onError);
-    }
-    constructor(...args){
-        super(...args);
-        this.extension = [
-            "png",
-            "jpg",
-            "webp",
-            "avif"
-        ];
-    }
-}
-
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol */
-
-
-function __decorate(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-  var e = new Error(message);
-  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
-class ClassProperties {
-    property(propertyKey, options = {}) {
-        this._properties[propertyKey] = options;
-        return this;
-    }
-    applyProperties(target) {
-        Object.assign(target, this._properties);
-        return target;
-    }
-    constructor(clsName){
-        this.clsName = clsName;
-        this._properties = Object.create(null);
-    }
-}
-class PropertyManager {
-    static _hasProperties(constructor) {
-        return PropertyManager._propertyMap.has(constructor);
-    }
-    static _getProperties(constructor, autoAdd = true) {
-        let props = PropertyManager._propertyMap.get(constructor);
-        if (props === undefined && autoAdd) {
-            props = Object.create(null);
-            PropertyManager._propertyMap.set(constructor, props);
-        }
-        return props;
-    }
-    static _getMergedProperties(constructor) {
-        let merged = null;
-        while(constructor !== Object.constructor.prototype){
-            let props = PropertyManager._getProperties(constructor, false);
-            if (props) {
-                if (merged === null) {
-                    merged = Object.create(null);
-                }
-                Object.assign(merged, props);
-            }
-            constructor = Object.getPrototypeOf(constructor);
-        }
-        return merged;
-    }
-    static _getClassProperties(clsName, autoAdd = true) {
-        let props = PropertyManager._classMap.get(clsName);
-        if (props === undefined && autoAdd) {
-            props = new ClassProperties(clsName);
-            PropertyManager._classMap.set(clsName, props);
-        }
-        return props;
-    }
-    static _applyClassProperties(clsName, constructor) {
-        let cls = PropertyManager._getClassProperties(clsName, false);
-        if (cls) {
-            return cls.applyProperties(PropertyManager._getProperties(constructor));
-        } else {
-            return PropertyManager._getProperties(constructor, false);
-        }
-    }
-}
-PropertyManager._classMap = new Map();
-PropertyManager._propertyMap = new Map();
-function property(target, propertyKey) {
-    let options = null;
-    function normalized(target, propertyKey) {
-        PropertyManager._getProperties(target.constructor)[propertyKey] = options;
-    }
-    if (target === undefined) {
-        return property({});
-    } else if (typeof propertyKey === "undefined") {
-        options = target;
-        return normalized;
-    } else {
-        options = {};
-        normalized(target, propertyKey);
-    }
-}
-
-const CinestationBlendStyle = {
-    Linear: Easing.Linear.None,
-    QuadraticIn: Easing.Quadratic.In,
-    QuadraticOut: Easing.Quadratic.Out,
-    QuadraticInOut: Easing.Quadratic.InOut
-};
-class CinestationBlendDefinition {
-    constructor(){
-        this.style = CinestationBlendStyle.QuadraticInOut;
-        this.time = 4;
-    }
-}
-__decorate([
-    property({
-        value: CinestationBlendStyle
-    })
-], CinestationBlendDefinition.prototype, "style", void 0);
-__decorate([
-    property
-], CinestationBlendDefinition.prototype, "time", void 0);
-
-class ObjectInstance {
-    constructor(){
-        this.instanceId = ObjectInstance._instanceCount++;
-        this.uuid = MathUtils.generateUUID();
-        this.name = "";
-        this.type = "ObjectInstance";
-    }
-}
-ObjectInstance._instanceCount = 0;
-
-class Component extends ObjectInstance {
-    get enabled() {
-        return this._enabled;
-    }
-    set enabled(v) {
-        if (this._enabled !== v) {
-            this._enabled = v;
-            this.manager.componentScheduler.enableComponent(this, v);
-        }
-    }
-    _onPreDestroy() {
-        this.unscheduleAll();
-        this.manager.removeComponent(this.node, this);
-        if (this._enabled) {
-            this.manager.componentScheduler.enableComponent(this, false);
-        }
-        if (this.onDestroy && this.flags.OnLoadCalled) {
-            this.onDestroy();
-        }
-    }
-    schedule(callback, interval, repeat = -1) {
-        this.manager.scheduler.schedule(this, callback, interval, repeat);
-    }
-    unshedule(callback) {
-        this.manager.scheduler.unshedule(this, callback);
-    }
-    unscheduleAll() {
-        this.manager.scheduler.unscheduleAll(this);
-    }
-    destroy() {
-        if (this.flags.Destroyed) {
-            return false;
-        }
-        this.destroyImmediate();
-        return true;
-    }
-    destroyImmediate() {
-        if (this._onPreDestroy) {
-            this._onPreDestroy();
-        }
-        this.flags.Destroyed = true;
-    }
-    constructor(...args){
-        super(...args);
-        this._enabled = true;
-        this.isComponent = true;
-        this.type = "Component";
-        this.flags = {};
-    }
-}
-
-const { clamp: clamp$4, lerp: lerp$1 } = MathUtils;
-class CinestationBrain extends Component {
-    get vcam() {
-        return this._vcam;
-    }
-    get vcams() {
-        return this._vcams;
-    }
-    lastUpdate(dt) {
-        let vcam = this.getActiveCamera();
-        if (vcam == null) return;
-        this._vcams.forEach((v)=>{
-            if (!v.locked) {
-                v.enabled = v === vcam;
-            }
-        });
-        if (this._lerpTime < this.brainBlend.time) {
-            this._lerpTime += dt;
-            let t = clamp$4(this._lerpTime / this.brainBlend.time, 0, 1);
-            this._lerpToMainCamera(vcam, this.brainBlend.style(t));
-        } else {
-            this._lerpToMainCamera(vcam, 1);
-        }
-    }
-    activeCamera(vcam, time = 4) {
-        if (this._vcamSolo !== vcam) {
-            this._vcamSolo = vcam;
-            this._lerpTime = 0;
-            this.brainBlend.time = time;
-        }
-    }
-    addCamera(vcam) {
-        let index = this._vcams.indexOf(vcam);
-        if (index === -1) {
-            this._vcams.push(vcam);
-        }
-    }
-    removeCamera(vcam) {
-        let index = this._vcams.indexOf(vcam);
-        if (index !== -1) {
-            this._vcams.splice(index, 1);
-        }
-    }
-    getActiveCamera() {
-        return this._vcamSolo || this._vcams.filter((v)=>v.enabled || v.locked).sort((a, b)=>b.priority - a.priority)[0];
-    }
-    _lerpToMainCamera(vcam, t) {
-        const from = this.node, to = vcam;
-        const { lens, finalPosition, finalRotation } = to;
-        const isLensChanged = from.fov != lens.fov || from.near != lens.near || from.far != lens.far;
-        from.position.lerp(finalPosition, t);
-        from.quaternion.slerp(finalRotation, t);
-        from.fov = lerp$1(from.fov, lens.fov, t);
-        from.near = lens.near;
-        from.far = lens.far;
-        if (isLensChanged) {
-            from.updateProjectionMatrix();
-        }
-    }
-    constructor(...args){
-        super(...args);
-        this._vcam = null;
-        this._vcamSolo = null;
-        this._vcams = [];
-        this._lerpTime = 4;
-        this.brainBlend = new CinestationBlendDefinition();
-    }
-}
-__decorate([
-    property
-], CinestationBrain.prototype, "brainBlend", void 0);
-
-class Lens {
-    constructor(){
-        this.fov = 45;
-        this.near = 0.1;
-        this.far = 1000;
-    }
-}
-__decorate([
-    property
-], Lens.prototype, "fov", void 0);
-__decorate([
-    property
-], Lens.prototype, "near", void 0);
-__decorate([
-    property
-], Lens.prototype, "far", void 0);
-class VirtualCamera extends Component {
-    get finalPosition() {
-        return this._finalPosition.copy(this.node.position).add(this.correctPosition);
-    }
-    get finalRotation() {
-        return this._finalRotation.copy(this.node.quaternion).multiply(this.correctRotation);
-    }
-    onLoad() {
-        const camera = this.viewer.camera;
-        this.node.isCamera = true;
-        this.lens.fov = camera.fov;
-        this.lens.near = camera.near;
-        this.lens.far = camera.far;
-        this.brain = this.manager.getComponent(camera, CinestationBrain, true);
-        this.brain.addCamera(this);
-    }
-    onDestroy() {
-        this.brain.removeCamera(this);
-    }
-    constructor(...args){
-        super(...args);
-        this._finalPosition = new Vector3();
-        this._finalRotation = new Quaternion();
-        this.locked = false;
-        this.priority = 10;
-        this.lens = new Lens();
-        this.correctPosition = new Vector3();
-        this.correctRotation = new Quaternion();
-    }
-}
-__decorate([
-    property
-], VirtualCamera.prototype, "lens", void 0);
-
-const PressState = {
-    NONE: 1 << 0,
-    SELECTED: 1 << 1,
-    IN: 1 << 2
-};
-class Pressability {
-    connect(target) {
-        let connector = this._connectors.find((v)=>v.target === target);
-        if (connector === undefined) {
-            connector = {
-                target,
-                state: PressState.NONE
-            };
-            this._connectors.push(connector);
-        }
-    }
-    disconnect(target) {
-        let index = this._connectors.findIndex((v)=>v.target === target);
-        if (index !== -1) {
-            this._connectors.splice(index, 1);
-        }
-    }
-    pointerDown(pointer, camera) {
-        if (this._connectors.length === 0) return;
-        this._raycaster.setFromCamera(pointer, camera);
-        for (let conn of this._connectors){
-            if (conn.target.has("click") || conn.target.has("pointerdown")) {
-                let intersects = this._raycaster.intersectObject(conn.target.node, true);
-                if (intersects.length) {
-                    conn.state |= PressState.SELECTED;
-                    conn.target.emit("pointerdown", {
-                        intersects
-                    });
-                }
-            }
-        }
-    }
-    pointerUp(pointer, camera) {
-        if (this._connectors.length === 0) return;
-        this._raycaster.setFromCamera(pointer, camera);
-        for (let conn of this._connectors){
-            if (conn.target.has("click") || conn.target.has("pointerup")) {
-                let intersects = this._raycaster.intersectObject(conn.target.node, true);
-                if (intersects.length) {
-                    if (conn.state & PressState.SELECTED) {
-                        conn.state &= ~PressState.SELECTED;
-                        conn.target.emit("click", {
-                            intersects
-                        });
-                    }
-                    conn.target.emit("pointerup", {
-                        intersects
-                    });
-                }
-            }
-        }
-    }
-    pointerMove(pointer, camera) {
-        if (this._connectors.length === 0) return;
-        this._raycaster.setFromCamera(pointer, camera);
-        for (let conn of this._connectors){
-            if (conn.target.has("pointerover") || conn.target.has("pointerout")) {
-                let intersects = this._raycaster.intersectObject(conn.target.node, true);
-                if (intersects.length) {
-                    if (!(conn.state & PressState.IN)) {
-                        conn.state |= PressState.IN;
-                        conn.target.emit("pointerover", {
-                            intersects
-                        });
-                    }
-                } else {
-                    if (conn.state & PressState.IN) {
-                        conn.state &= ~PressState.IN;
-                        conn.target.emit("pointerout", {
-                            intersects
-                        });
-                    }
-                }
-            }
-        }
-    }
-    constructor(){
-        this._raycaster = new Raycaster();
-        this._connectors = [];
-    }
-}
-
-class DeviceInput {
-    get pointerButton() {
-        return this._pointerButton;
-    }
-    get pointer() {
-        return this._pointer;
-    }
-    get pointerPosition() {
-        return this._pointerPosition;
-    }
-    get mouseWheel() {
-        return this._mouseWheel;
-    }
-    get touchCount() {
-        return this._touchCount;
-    }
-    get touches() {
-        return this._touches;
-    }
-    get keys() {
-        return this._keys;
-    }
-    addEventListeners() {
-        const { canvas } = this.viewer;
-        canvas.style.touchAction = 'none';
-        this._addEventListener(canvas, 'contextmenu', (e)=>e.preventDefault());
-        this._addEventListener(canvas, "pointerdown", (e)=>this._onPointerDown(e), {
-            passive: false
-        });
-        this._addEventListener(canvas, "pointerup", (e)=>this._onPointerUp(e), {
-            passive: false
-        });
-        this._addEventListener(canvas, "pointercancel", (e)=>this._onPointerUp(e), {
-            passive: false
-        });
-        this._addEventListener(canvas, "pointerout", (e)=>this._onPointerUp(e), {
-            passive: false
-        });
-        this._addEventListener(canvas, "pointermove", (e)=>this._onPointerMove(e), {
-            passive: true
-        });
-        this._addEventListener(canvas, "wheel", (e)=>this._onMouseWheel(e), {
-            passive: false
-        });
-        this._addEventListener(canvas, "touchstart", (e)=>this._onTouchStart(e), {
-            passive: true
-        });
-        this._addEventListener(canvas, "touchend", (e)=>this._onTouchEnd(e), {
-            passive: true
-        });
-        this._addEventListener(canvas, "touchmove", (e)=>this._onTouchMove(e), {
-            passive: true
-        });
-        //监听了pointer事件之后，key事件失效，改成window解决
-        this._addEventListener(window, "keydown", (e)=>this._onKeyDown(e), {
-            passive: false
-        });
-        this._addEventListener(window, "keypress", (e)=>this._onKeyPress(e), {
-            passive: false
-        });
-        this._addEventListener(window, "keyup", (e)=>this._onKeyUp(e), {
-            passive: false
-        });
-        this._addEventListener(window, "resize", (e)=>this._onResize(e), {
-            passive: false
-        });
-    }
-    removeAllListeners() {
-        for (let { target, type, callback } of this._listeners){
-            if (target.removeEventListener) target.removeEventListener(type, callback);
-            else if (target.off) target.off(type, callback, target);
-        }
-        this._listeners = [];
-    }
-    connect(target, event) {
-        switch(event){
-            case DeviceInput.CLICK:
-            case DeviceInput.POINTER_DOWN:
-            case DeviceInput.POINTER_UP:
-            case DeviceInput.POINTER_OVER:
-            case DeviceInput.POINTER_OUT:
-                this._pressability.connect(target);
-                break;
-        }
-    }
-    disconnect(target) {
-        this._pressability.disconnect(target);
-    }
-    _addEventListener(target, type, callback, options) {
-        if (target.addEventListener) target.addEventListener(type, callback, options);
-        else if (target.on) target.on(type, callback, target);
-        this._listeners.push({
-            target,
-            type,
-            callback
-        });
-    }
-    _onResize(e) {
-        this.viewer.rotate();
-        this.viewer.resize();
-    }
-    _remapPointer(e) {
-        const width = this.viewer.width;
-        return this.viewer.rootRotated ? {
-            button: e.button,
-            buttons: e.buttons,
-            clientX: e.clientY,
-            clientY: width - e.clientX,
-            offsetX: e.offsetY,
-            offsetY: width - e.offsetX,
-            pageX: e.pageY,
-            pageY: width - e.pageX,
-            screenX: e.screenY,
-            screenY: width - e.screenX,
-            movementX: e.movementY,
-            movementY: e.movementX
-        } : e;
-    }
-    _remapTouch(e) {
-        const width = this.viewer.width;
-        return this.viewer.rootRotated ? {
-            touches: Array.from(e.touches).map((v)=>{
-                return {
-                    identifier: v.identifier,
-                    clientX: v.clientY,
-                    clientY: width - v.clientX,
-                    pageX: v.pageY,
-                    pageY: width - v.pageX,
-                    screenX: v.screenY,
-                    screenY: width - v.screenX
-                };
-            })
-        } : e;
-    }
-    _computePointer(e) {
-        this._pointer.x = e.offsetX / this.viewer.width * 2 - 1;
-        this._pointer.y = 1 - e.offsetY / this.viewer.height * 2;
-        this._pointerPosition.set(e.offsetX, e.offsetY);
-    }
-    _onPointerDown(e) {
-        e.preventDefault();
-        e = this._remapPointer(e);
-        this._pointerButton = e.button;
-        this._computePointer(e);
-        this._pressability.pointerDown(this._pointer, this.viewer.camera);
-        this.viewer.emit(DeviceInput.POINTER_DOWN, e);
-    }
-    _onPointerUp(e) {
-        e.preventDefault();
-        e = this._remapPointer(e);
-        this._pointerButton = -1;
-        this._computePointer(e);
-        this._pressability.pointerUp(this._pointer, this.viewer.camera);
-        this.viewer.emit(DeviceInput.POINTER_UP, e);
-    }
-    _onPointerMove(e) {
-        e = this._remapPointer(e);
-        this._computePointer(e);
-        this._pressability.pointerMove(this._pointer, this.viewer.camera);
-        this.viewer.emit(DeviceInput.POINTER_MOVE, e);
-    }
-    _onMouseWheel(e) {
-        e.preventDefault();
-        this._mouseWheel = e.deltaY || e.wheelDelta;
-        this.viewer.emit(DeviceInput.MOUSE_WHEEL, e);
-    }
-    _onTouchStart(e) {
-        e = this._remapTouch(e);
-        this.viewer.emit(DeviceInput.TOUCH_START, e);
-    }
-    _onTouchEnd(e) {
-        e = this._remapTouch(e);
-        this.viewer.emit(DeviceInput.TOUCH_END, e);
-    }
-    _onTouchMove(e) {
-        e = this._remapTouch(e);
-        let touches = e.touches;
-        let touchesTo = this._touches;
-        for(let i = touches.length; i--;){
-            if (touchesTo[i] == undefined) {
-                touchesTo[i] = {
-                    id: -1,
-                    position: new Vector2()
-                };
-            }
-            const touch = touches[i];
-            touchesTo[i].id = touch.identifier;
-            touchesTo[i].position.set(touch.pageX, touch.pageY);
-        }
-        this._touchCount = touches.length;
-        this.viewer.emit(DeviceInput.TOUCH_MOVE, e);
-    }
-    _onKeyDown(e) {
-        this._keys[e.key] = true;
-        this.viewer.emit(DeviceInput.KEYDOWN, e);
-    }
-    _onKeyPress(e) {
-        this._keys[e.key] = true;
-        this.viewer.emit(DeviceInput.KEYPRESS, e);
-    }
-    _onKeyUp(e) {
-        this._keys[e.key] = false;
-        this.viewer.emit(DeviceInput.KEYUP, e);
-    }
-    constructor(viewer){
-        this.viewer = viewer;
-        this._listeners = [];
-        this._mouseWheel = 0;
-        this._touches = [];
-        this._touchCount = 0;
-        this._pointerButton = -1;
-        this._pointerPosition = new Vector2();
-        this._pointer = new Vector2();
-        this._keys = {};
-        this._pressability = new Pressability();
-    }
-}
-DeviceInput.CLICK = "click";
-DeviceInput.MOUSE_WHEEL = "mousewheel";
-DeviceInput.TOUCH_START = "touchstart";
-DeviceInput.TOUCH_END = "touchend";
-DeviceInput.TOUCH_MOVE = "touchmove";
-DeviceInput.POINTER_DOWN = "pointerdown";
-DeviceInput.POINTER_UP = "pointerup";
-DeviceInput.POINTER_MOVE = "pointermove";
-DeviceInput.POINTER_OVER = "pointerover";
-DeviceInput.POINTER_OUT = "pointerout";
-DeviceInput.KEYDOWN = "keydown";
-DeviceInput.KEYPRESS = "keypress";
-DeviceInput.KEYUP = "keyup";
-
-const isSSR = typeof window === 'undefined';
-class DetectUA {
-    /**
-     * Match entry based on position found in the user-agent string
-     *
-     * @param pattern regular expression pattern
-     */ match(position, pattern) {
-        const match = this.userAgent.match(pattern);
-        return match && match.length > 1 && match[position] || '';
-    }
-    /**
-     * Returns if the device is a mobile device
-     */ get isMobile() {
-        return(// Default mobile
-        !this.isTablet && (/[^-]mobi/i.test(this.userAgent) || // iPhone / iPod
-        this.iOSDevice === 'iphone' || this.iOSDevice === 'ipod' || // Android
-        this.isAndroidDevice || // Nexus mobile
-        /nexus\s*[0-6]\s*/i.test(this.userAgent)));
-    }
-    /**
-     * Returns if the device is a tablet device
-     */ get isTablet() {
-        return(// Default tablet
-        /tablet/i.test(this.userAgent) && !/tablet pc/i.test(this.userAgent) || // iPad
-        this.iOSDevice === 'ipad' || // Android
-        this.isAndroidDevice && !/[^-]mobi/i.test(this.userAgent) || // Nexus tablet
-        !/nexus\s*[0-6]\s*/i.test(this.userAgent) && /nexus\s*[0-9]+/i.test(this.userAgent));
-    }
-    /**
-     * Returns if the device is a desktop device
-     */ get isDesktop() {
-        return !this.isMobile && !this.isTablet;
-    }
-    /**
-     * Returns if the device is running MacOS (and if so which version)
-     *
-     * '5' => Leopard'
-     * '6' => Snow Leopard'
-     * '7' => Lion'
-     * '8' => Mountain Lion'
-     * '9' => Mavericks'
-     * '10' => Yosemite'
-     * '11' => El Capitan'
-     * '12' => Sierra'
-     * '13' => High Sierra'
-     * '14' => Mojave'
-     * '15' => Catalina'
-     */ get isMacOS() {
-        return /macintosh/i.test(this.userAgent) && {
-            version: this.match(1, /mac os x (\d+(\.?_?\d+)+)/i).replace(/[_\s]/g, '.').split('.').map((versionNumber)=>versionNumber)[1]
-        };
-    }
-    /**
-     * Returns if the device is running Windows (and if so which version)
-     *
-     * 'NT' => 'NT'
-     * 'XP' => 'XP'
-     * 'NT 5.0' => '2000'
-     * 'NT 5.1' => 'XP'
-     * 'NT 5.2' => '2003'
-     * 'NT 6.0' => 'Vista'
-     * 'NT 6.1' => '7'
-     * 'NT 6.2' => '8'
-     * 'NT 6.3' => '8.1'
-     * 'NT 10.0' => '10'
-     */ get isWindows() {
-        return /windows /i.test(this.userAgent) && {
-            version: this.match(1, /Windows ((NT|XP)( \d\d?.\d)?)/i)
-        };
-    }
-    /**
-     * Returns if the device is an iOS device (and if so which version)
-     */ get isiOS() {
-        return !!this.iOSDevice && {
-            version: this.match(1, /os (\d+([_\s]\d+)*) like mac os x/i).replace(/[_\s]/g, '.') || this.match(1, /version\/(\d+(\.\d+)?)/i)
-        };
-    }
-    /**
-     * Returns if the device is an Android device (and if so which version)
-     */ get isAndroid() {
-        return this.isAndroidDevice && {
-            version: this.match(1, /android[ \/-](\d+(\.\d+)*)/i)
-        };
-    }
-    /**
-     * Returns the browser name and version
-     */ get browser() {
-        const versionIdentifier = this.match(1, /version\/(\d+(\.\d+)?)/i);
-        if (/opera/i.test(this.userAgent)) {
-            // Opera
-            return {
-                name: 'Opera',
-                version: versionIdentifier || this.match(1, /(?:opera|opr|opios)[\s\/](\d+(\.\d+)?)/i)
-            };
-        } else if (/opr\/|opios/i.test(this.userAgent)) {
-            // Opera
-            return {
-                name: 'Opera',
-                version: this.match(1, /(?:opr|opios)[\s\/](\d+(\.\d+)?)/i) || versionIdentifier
-            };
-        } else if (/SamsungBrowser/i.test(this.userAgent)) {
-            // Samsung Browser
-            return {
-                name: 'Samsung Internet for Android',
-                version: versionIdentifier || this.match(1, /(?:SamsungBrowser)[\s\/](\d+(\.\d+)?)/i)
-            };
-        } else if (/yabrowser/i.test(this.userAgent)) {
-            // Yandex Browser
-            return {
-                name: 'Yandex Browser',
-                version: versionIdentifier || this.match(1, /(?:yabrowser)[\s\/](\d+(\.\d+)?)/i)
-            };
-        } else if (/ucbrowser/i.test(this.userAgent)) {
-            // UC Browser
-            return {
-                name: 'UC Browser',
-                version: this.match(1, /(?:ucbrowser)[\s\/](\d+(\.\d+)?)/i)
-            };
-        } else if (/msie|trident/i.test(this.userAgent)) {
-            // Internet Explorer
-            return {
-                name: 'Internet Explorer',
-                version: this.match(1, /(?:msie |rv:)(\d+(\.\d+)?)/i)
-            };
-        } else if (/(edge|edgios|edga|edg)/i.test(this.userAgent)) {
-            // Edge
-            return {
-                name: 'Microsoft Edge',
-                version: this.match(2, /(edge|edgios|edga|edg)\/(\d+(\.\d+)?)/i)
-            };
-        } else if (/firefox|iceweasel|fxios/i.test(this.userAgent)) {
-            // Firefox
-            return {
-                name: 'Firefox',
-                version: this.match(1, /(?:firefox|iceweasel|fxios)[ \/](\d+(\.\d+)?)/i)
-            };
-        } else if (/chromium/i.test(this.userAgent)) {
-            // Chromium
-            return {
-                name: 'Chromium',
-                version: this.match(1, /(?:chromium)[\s\/](\d+(?:\.\d+)?)/i) || versionIdentifier
-            };
-        } else if (/chrome|crios|crmo/i.test(this.userAgent)) {
-            // Chrome
-            return {
-                name: 'Chrome',
-                version: this.match(1, /(?:chrome|crios|crmo)\/(\d+(\.\d+)?)/i)
-            };
-        } else if (/safari|applewebkit/i.test(this.userAgent)) {
-            // Safari
-            return {
-                name: 'Safari',
-                version: versionIdentifier
-            };
-        } else {
-            // Everything else
-            return {
-                name: this.match(1, /^(.*)\/(.*) /),
-                version: this.match(2, /^(.*)\/(.*) /)
-            };
-        }
-    }
-    /**
-     * Detect a users browser, browser version and whether it is a mobile-, tablet- or desktop device
-     *
-     * @param forceUserAgent Force a user agent string (useful for testing)
-     */ constructor(forceUserAgent){
-        this.userAgent = forceUserAgent ? forceUserAgent : !isSSR && window.navigator ? window.navigator.userAgent : '';
-        this.isAndroidDevice = !/like android/i.test(this.userAgent) && /android/i.test(this.userAgent);
-        this.iOSDevice = this.match(1, /(iphone|ipod|ipad)/i).toLowerCase();
-        // Workaround for ipadOS, force detection as tablet
-        // SEE: https://github.com/lancedikson/bowser/issues/329
-        // SEE: https://stackoverflow.com/questions/58019463/how-to-detect-device-name-in-safari-on-ios-13-while-it-doesnt-show-the-correct
-        if (!isSSR && navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 2 && !window.MSStream) {
-            this.iOSDevice = 'ipad';
-        }
-    }
-}
-
-const detectUA = new DetectUA();
-const userAgent = (navigator.userAgent || navigator.vendor).toLowerCase();
-const browserName = typeof detectUA.browser === "boolean" ? "" : detectUA.browser.name;
-const audioElem = document.createElement("audio");
-class SystemInfo {
-}
-SystemInfo.isTablet = detectUA.isTablet;
-SystemInfo.isMobile = detectUA.isMobile || detectUA.isTablet;
-SystemInfo.isDesktop = detectUA.isDesktop;
-SystemInfo.device = SystemInfo.isMobile ? "mobile" : "desktop";
-SystemInfo.isAndroid = !!detectUA.isAndroid;
-SystemInfo.isIOS = !!detectUA.isiOS;
-SystemInfo.isMacOS = !!detectUA.isMacOS;
-SystemInfo.isWindows = typeof detectUA.isWindows === "boolean" ? detectUA.isWindows : detectUA.isWindows.version !== null;
-SystemInfo.isLinux = userAgent.indexOf("linux") != -1;
-SystemInfo.ua = userAgent;
-SystemInfo.isEdge = browserName === "Microsoft Edge";
-SystemInfo.isIE = browserName === "Internet Explorer";
-SystemInfo.isFirefox = browserName === "Firefox";
-SystemInfo.isChrome = browserName === "Chrome";
-SystemInfo.isOpera = browserName === "Opera";
-SystemInfo.isSafari = browserName === "Safari";
-SystemInfo.isSupportMSAA = !userAgent.match("version/15.4 ");
-SystemInfo.isSupportOgg = !!audioElem.canPlayType("audio/ogg");
-SystemInfo.isRetina = window.devicePixelRatio && window.devicePixelRatio >= 1.5;
-SystemInfo.devicePixelRatio = window.devicePixelRatio || 1;
-SystemInfo.cpuCoreCount = navigator.hardwareConcurrency || 1;
-SystemInfo.baseUrl = document.location.origin;
-SystemInfo.isIFrame = window.self !== window.top;
-
-const { clamp: clamp$3 } = MathUtils;
-const { min, max: max$1, exp } = Math;
-const kNegligibleResidual = 0.01;
-const kLogNegligibleResidual = Math.log(kNegligibleResidual) // -4.605170186;
-;
-function exponentialDamp(current, target, dampTime, deltaTime) {
-    let k = -kLogNegligibleResidual / dampTime;
-    return current + (target - current) * (1 - exp(-k * deltaTime));
-}
-// cuve like exponentialDecay but cost less
-function quarticDamp(current, target, dampTime, deltaTime) {
-    let t = 1 - min(deltaTime, dampTime) / dampTime;
-    let tt = t * t;
-    return current + (target - current) * (1 - tt * tt);
-}
-function smoothDamp(state, current, target, smoothTime, maxSpeed, deltaTime) {
-    if (state._velocity === undefined) {
-        state._velocity = 0;
-    }
-    smoothTime = max$1(0.0001, smoothTime);
-    let num = 2 / smoothTime;
-    let num2 = num * deltaTime;
-    let num3 = 1 / (1 + num2 + 0.48 * num2 * num2 + 0.235 * num2 * num2 * num2);
-    let num4 = current - target;
-    let num5 = target;
-    let num6 = maxSpeed * smoothTime;
-    num4 = clamp$3(num4, -num6, num6);
-    target = current - num4;
-    let num7 = (state._velocity + num * num4) * deltaTime;
-    state._velocity = (state._velocity - num * num7) * num3;
-    let num8 = target + (num4 + num7) * num3;
-    if (num5 - current > 0 == num8 > num5) {
-        num8 = num5;
-        state._velocity = (num8 - num5) / deltaTime;
-    }
-    return num8;
-}
-function Quat_exponentialDamp(current, target, dampTime, deltaTime, out = current) {
-    return out.copy(current).slerp(target, exponentialDamp(0, 1, dampTime, deltaTime));
-}
-function Quat_quarticDamp(current, target, dampTime, deltaTime, out = current) {
-    return out.copy(current).slerp(target, quarticDamp(0, 1, dampTime, deltaTime));
-}
-function Quat_smoothDamp(current, target, dampTime, deltaTime, out = current) {
-    return out.copy(current).slerp(target, smoothDamp(out, 0, 1, dampTime, Infinity, deltaTime));
-}
-function Vec3_smoothDamp(current, target, dampTime, deltaTime, out = current) {
-    return out.copy(current).lerp(target, smoothDamp(out, 0, 1, dampTime, Infinity, deltaTime));
-}
-
-const Vector3_UNIT_X = Object.freeze(new Vector3(1, 0, 0));
-const Vector3_UNIT_Y = Object.freeze(new Vector3(0, 1, 0));
-const Vector3_UNIT_Z = Object.freeze(new Vector3(0, 0, 1));
-const Vector3_RIGHT = Object.freeze(new Vector3(1, 0, 0));
-const Vector3_UP = Object.freeze(new Vector3(0, 1, 0));
-const Vector3_ZERO = Object.freeze(new Vector3(0, 0, 0));
-const Vector3_ONE = Object.freeze(new Vector3(1, 1, 1));
-const Vector3_NEG_ONE = Object.freeze(new Vector3(-1, -1, -1));
-
-const { clamp: clamp$2 } = MathUtils;
-const { max, abs: abs$1, acos } = Math;
-const EPSILON = 1.e-6;
-const __deltaMap = new Map();
-__deltaMap.set(Vector3, new Vector3());
-__deltaMap.set(Vector2, new Vector2());
-function VInterpTo(current, target, deltaTime, speed, out = current, epsilon = EPSILON) {
-    if (speed <= 0) {
-        return out.copy(target);
-    }
-    let dist = __deltaMap.get(current.constructor).copy(target).sub(current);
-    if (dist.lengthSq() < epsilon) {
-        return out.copy(target);
-    }
-    return out.copy(current).add(dist.multiplyScalar(clamp$2(deltaTime * speed, 0, 1)));
-}
-function VInterpConstantTo(current, target, deltaTime, speed, out = current) {
-    let delta = __deltaMap.get(current.constructor).copy(target).sub(current);
-    let deltaM = delta.length();
-    let maxStep = speed * deltaTime;
-    if (deltaM > maxStep) {
-        if (maxStep > 0) {
-            let deltaN = delta.multiplyScalar(1 / deltaM);
-            return out.copy(current).add(deltaN);
-        } else {
-            return out.copy(current);
-        }
-    }
-    return out.copy(target);
-}
-function Quat_Equals(a, b, epsilon = EPSILON) {
-    return abs$1(a.x - b.x) <= epsilon * max(1., abs$1(a.x), abs$1(b.x)) && abs$1(a.y - b.y) <= epsilon * max(1., abs$1(a.y), abs$1(b.y)) && abs$1(a.z - b.z) <= epsilon * max(1., abs$1(a.z), abs$1(b.z)) && abs$1(a.w - b.w) <= epsilon * max(1., abs$1(a.w), abs$1(b.w));
-}
-function Quat_AngularDistance(a, b) {
-    let innerProd = a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
-    return acos(2 * innerProd * innerProd - 1);
-}
-function QInterpTo(current, target, deltaTime, speed, epsilon = EPSILON) {
-    if (speed <= 0) {
-        return target;
-    }
-    if (Quat_Equals(current, target, epsilon)) {
-        return target;
-    }
-    return current.slerp(target, clamp$2(speed * deltaTime, 0, 1));
-}
-function QInterpConstantTo(current, target, deltaTime, speed, out = current) {
-    if (speed <= 0) {
-        return out.copy(target);
-    }
-    if (Quat_Equals(current, target)) {
-        return out.copy(target);
-    }
-    let deltaSpeed = clamp$2(speed * deltaTime, 0, 1);
-    let angularDist = max(Quat_AngularDistance(current, target), EPSILON);
-    return out.copy(current).slerp(target, clamp$2(deltaSpeed / angularDist, 0, 1));
-}
-//非线性
-function FInterpTo(current, target, deltaTime, speed, epsilon = EPSILON) {
-    if (speed <= 0) {
-        return target;
-    }
-    let dist = target - current;
-    if (abs$1(dist) < epsilon) {
-        return target;
-    }
-    return current + dist * clamp$2(speed * deltaTime, 0, 1);
-}
-//线性插值
-function FInterpConstantTo(current, target, deltaTime, speed, epsilon = EPSILON) {
-    let dist = target - current;
-    if (abs$1(dist) < epsilon) {
-        return target;
-    }
-    let step = speed * deltaTime;
-    return current + clamp$2(dist, -step, step);
-}
-
-const { lerp, clamp: clamp$1 } = MathUtils;
-function catmullRom(t, p0, p1, p2, p3) {
-    const v0 = (p2 - p0) * 0.5;
-    const v1 = (p3 - p1) * 0.5;
-    const t2 = t * t;
-    const t3 = t * t2;
-    return (2 * p1 - 2 * p2 + v0 + v1) * t3 + (-3 * p1 + 3 * p2 - 2 * v0 - v1) * t2 + v0 * t + p1;
-}
-class CurvePoint {
-    set(x, y) {
-        this.x = x;
-        this.y = y;
-        return this;
-    }
-    lerp(p, t, out = this) {
-        out.x = lerp(this.x, p.x, t);
-        out.y = lerp(this.y, p.y, t);
-        return out;
-    }
-    constructor(x = 0, y = 0, mode = 0){
-        this.x = x;
-        this.y = y;
-        this.mode = mode;
-    }
-}
-class AnimationCurve {
-    _getInterpolant(samples) {
-        if (this._samples !== samples) {
-            this._samples = samples;
-            this._interpolant = new LinearInterpolant(new Float32Array(samples), new Float32Array(samples), 1, new Float32Array(samples));
-        }
-        return this._interpolant;
-    }
-    createCurvePoint(x, y, mode) {
-        return new CurvePoint(x, y, mode);
-    }
-    resample(samples = 100) {
-        const step = 1 / (samples - 1);
-        const interpolant = this._getInterpolant(samples);
-        const times = interpolant.parameterPositions;
-        const values = interpolant.sampleValues;
-        const point = this.createCurvePoint();
-        for(let i = 0; i < samples; i++){
-            this.getPoint(i * step, point);
-            times[i] = point.x;
-            values[i] = point.y;
-        }
-    }
-    evaluate(t) {
-        if (this.needsUpdate) {
-            this.needsUpdate = false;
-            this.resample();
-        }
-        return this._interpolant.evaluate(t)[0];
-    }
-    getPoint(t, out) {
-        const points = this.points;
-        if (t <= 0) {
-            return out.set(t, points[0].y);
-        }
-        if (t >= 1) {
-            return out.set(t, points[points.length - 1].y);
-        }
-        const p = (points.length - 1) * t;
-        const intPoint = Math.floor(p);
-        const weight = p - intPoint;
-        const p0 = points[intPoint === 0 ? intPoint : intPoint - 1];
-        const p1 = points[intPoint];
-        const p2 = points[intPoint > points.length - 2 ? points.length - 1 : intPoint + 1];
-        const p3 = points[intPoint > points.length - 3 ? points.length - 1 : intPoint + 2];
-        if (p1.mode === 1 || p0 === p1 && p2.mode === 1) {
-            return p1.lerp(p2, weight, out);
-        }
-        return out.set(clamp$1(catmullRom(weight, p0.x, p1.x, p2.x, p3.x), 0, 1), clamp$1(catmullRom(weight, p0.y, p1.y, p2.y, p3.y), 0, 1));
-    }
-    constructor(name = "", points = [
-        new CurvePoint(0, 0),
-        new CurvePoint(1, 1)
-    ]){
-        this.name = name;
-        this.points = points;
-        this.needsUpdate = true;
-        this.isAnimationCurve = true;
-        this._samples = 100;
-        this._interpolant = new LinearInterpolant(new Float32Array(100), new Float32Array(100), 1, new Float32Array(100));
-    }
-}
-
-const { floor } = Math;
-// Copyright (C) 2016 Keijiro Takahashi
-// https://mrl.cs.nyu.edu/~perlin/noise/
-class Perlin {
-    static Noise(x, y, z) {
-        let fade = Perlin._Fade;
-        let grad = Perlin._Grad;
-        let lerp = Perlin._Lerp;
-        let p = Perlin._Permutation;
-        if (y !== undefined && z !== undefined) {
-            let xi = floor(x);
-            let yi = floor(y);
-            let zi = floor(z);
-            let X = xi & 0xff; // FIND UNIT CUBE THAT
-            let Y = yi & 0xff; // CONTAINS POINT.
-            let Z = zi & 0xff;
-            x -= xi; // FIND RELATIVE X,Y,Z
-            y -= yi; // OF POINT IN CUBE.
-            z -= zi;
-            let u = fade(x); // COMPUTE FADE CURVES
-            let v = fade(y); // FOR EACH OF X,Y,Z.
-            let w = fade(z);
-            let A = p[X] + Y, AA = p[A] + Z, AB = p[A + 1] + Z; // HASH COORDINATES OF
-            let B = p[X + 1] + Y, BA = p[B] + Z, BB = p[B + 1] + Z; // THE 8 CUBE CORNERS,
-            return lerp(w, lerp(v, lerp(u, grad(p[AA], x, y, z), grad(p[BA], x - 1, y, z)), lerp(u, grad(p[AB], x, y - 1, z), grad(p[BB], x - 1, y - 1, z))), lerp(v, lerp(u, grad(p[AA + 1], x, y, z - 1), grad(p[BA + 1], x - 1, y, z - 1)), lerp(u, grad(p[AB + 1], x, y - 1, z - 1), grad(p[BB + 1], x - 1, y - 1, z - 1))));
-        } else if (y !== undefined) {
-            let xi = floor(x);
-            let yi = floor(y);
-            let X = xi & 0xff;
-            let Y = yi & 0xff;
-            x -= xi;
-            y -= yi;
-            let u = fade(x);
-            let v = fade(y);
-            let A = p[X] + Y & 0xff;
-            let B = p[X + 1] + Y & 0xff;
-            return lerp(v, lerp(u, grad(p[A], x, y), grad(p[B], x - 1, y)), lerp(u, grad(p[A + 1], x, y - 1), grad(p[B + 1], x - 1, y - 1)));
-        } else {
-            let xi = floor(x);
-            let X = xi & 0xff;
-            x -= xi;
-            let u = fade(x);
-            return lerp(u, grad(p[X], x), grad(p[X + 1], x - 1));
-        }
-    }
-    static Fbm(octave, x, y, z) {
-        let f = 0;
-        let w = 0.5;
-        let noise = Perlin.Noise;
-        if (y !== undefined && z !== undefined) {
-            for(let i = 0; i < octave; i++){
-                f += w * noise(x, y, z);
-                x *= 2.0;
-                y *= 2.0;
-                z *= 2.0;
-                w *= 0.5;
-            }
-        } else if (y !== undefined) {
-            for(let i = 0; i < octave; i++){
-                f += w * noise(x, y);
-                x *= 2.0;
-                y *= 2.0;
-                w *= 0.5;
-            }
-        } else {
-            for(let i = 0; i < octave; i++){
-                f += w * noise(x);
-                x *= 2.0;
-                w *= 0.5;
-            }
-        }
-        return f;
-    }
-    static _Fade(t) {
-        return t * t * t * (t * (t * 6 - 15) + 10);
-    }
-    static _Lerp(t, a, b) {
-        return a + t * (b - a);
-    }
-    static _Grad(hash, x, y, z) {
-        if (y !== undefined && z !== undefined) {
-            let h = hash & 15; // CONVERT LO 4 BITS OF HASH CODE
-            let u = h < 8 ? x : y, v = h < 4 ? y : h == 12 || h == 14 ? x : z;
-            return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
-        } else if (y !== undefined) {
-            return ((hash & 1) == 0 ? x : -x) + ((hash & 2) == 0 ? y : -y);
-        } else {
-            return (hash & 1) == 0 ? x : -x;
+    static _Grad(hash, x, y, z) {
+        if (y !== undefined && z !== undefined) {
+            let h = hash & 15; // CONVERT LO 4 BITS OF HASH CODE
+            let u = h < 8 ? x : y, v = h < 4 ? y : h == 12 || h == 14 ? x : z;
+            return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
+        } else if (y !== undefined) {
+            return ((hash & 1) == 0 ? x : -x) + ((hash & 2) == 0 ? y : -y);
+        } else {
+            return (hash & 1) == 0 ? x : -x;
         }
     }
 }
@@ -2688,6 +1030,1091 @@ Perlin._Permutation = [
     151
 ];
 
+/**
+ * The Ease class provides a collection of easing functions for use with tween.js.
+ */ const Easing = Object.freeze({
+    Linear: Object.freeze({
+        None (amount) {
+            return amount;
+        },
+        In (amount) {
+            return amount;
+        },
+        Out (amount) {
+            return amount;
+        },
+        InOut (amount) {
+            return amount;
+        }
+    }),
+    Quadratic: Object.freeze({
+        In (amount) {
+            return amount * amount;
+        },
+        Out (amount) {
+            return amount * (2 - amount);
+        },
+        InOut (amount) {
+            if ((amount *= 2) < 1) {
+                return 0.5 * amount * amount;
+            }
+            return -0.5 * (--amount * (amount - 2) - 1);
+        }
+    }),
+    Cubic: Object.freeze({
+        In (amount) {
+            return amount * amount * amount;
+        },
+        Out (amount) {
+            return --amount * amount * amount + 1;
+        },
+        InOut (amount) {
+            if ((amount *= 2) < 1) {
+                return 0.5 * amount * amount * amount;
+            }
+            return 0.5 * ((amount -= 2) * amount * amount + 2);
+        }
+    }),
+    Quartic: Object.freeze({
+        In (amount) {
+            return amount * amount * amount * amount;
+        },
+        Out (amount) {
+            return 1 - --amount * amount * amount * amount;
+        },
+        InOut (amount) {
+            if ((amount *= 2) < 1) {
+                return 0.5 * amount * amount * amount * amount;
+            }
+            return -0.5 * ((amount -= 2) * amount * amount * amount - 2);
+        }
+    }),
+    Quintic: Object.freeze({
+        In (amount) {
+            return amount * amount * amount * amount * amount;
+        },
+        Out (amount) {
+            return --amount * amount * amount * amount * amount + 1;
+        },
+        InOut (amount) {
+            if ((amount *= 2) < 1) {
+                return 0.5 * amount * amount * amount * amount * amount;
+            }
+            return 0.5 * ((amount -= 2) * amount * amount * amount * amount + 2);
+        }
+    }),
+    Sinusoidal: Object.freeze({
+        In (amount) {
+            return 1 - Math.sin((1.0 - amount) * Math.PI / 2);
+        },
+        Out (amount) {
+            return Math.sin(amount * Math.PI / 2);
+        },
+        InOut (amount) {
+            return 0.5 * (1 - Math.sin(Math.PI * (0.5 - amount)));
+        }
+    }),
+    Exponential: Object.freeze({
+        In (amount) {
+            return amount === 0 ? 0 : Math.pow(1024, amount - 1);
+        },
+        Out (amount) {
+            return amount === 1 ? 1 : 1 - Math.pow(2, -10 * amount);
+        },
+        InOut (amount) {
+            if (amount === 0) {
+                return 0;
+            }
+            if (amount === 1) {
+                return 1;
+            }
+            if ((amount *= 2) < 1) {
+                return 0.5 * Math.pow(1024, amount - 1);
+            }
+            return 0.5 * (-Math.pow(2, -10 * (amount - 1)) + 2);
+        }
+    }),
+    Circular: Object.freeze({
+        In (amount) {
+            return 1 - Math.sqrt(1 - amount * amount);
+        },
+        Out (amount) {
+            return Math.sqrt(1 - --amount * amount);
+        },
+        InOut (amount) {
+            if ((amount *= 2) < 1) {
+                return -0.5 * (Math.sqrt(1 - amount * amount) - 1);
+            }
+            return 0.5 * (Math.sqrt(1 - (amount -= 2) * amount) + 1);
+        }
+    }),
+    Elastic: Object.freeze({
+        In (amount) {
+            if (amount === 0) {
+                return 0;
+            }
+            if (amount === 1) {
+                return 1;
+            }
+            return -Math.pow(2, 10 * (amount - 1)) * Math.sin((amount - 1.1) * 5 * Math.PI);
+        },
+        Out (amount) {
+            if (amount === 0) {
+                return 0;
+            }
+            if (amount === 1) {
+                return 1;
+            }
+            return Math.pow(2, -10 * amount) * Math.sin((amount - 0.1) * 5 * Math.PI) + 1;
+        },
+        InOut (amount) {
+            if (amount === 0) {
+                return 0;
+            }
+            if (amount === 1) {
+                return 1;
+            }
+            amount *= 2;
+            if (amount < 1) {
+                return -0.5 * Math.pow(2, 10 * (amount - 1)) * Math.sin((amount - 1.1) * 5 * Math.PI);
+            }
+            return 0.5 * Math.pow(2, -10 * (amount - 1)) * Math.sin((amount - 1.1) * 5 * Math.PI) + 1;
+        }
+    }),
+    Back: Object.freeze({
+        In (amount) {
+            const s = 1.70158;
+            return amount === 1 ? 1 : amount * amount * ((s + 1) * amount - s);
+        },
+        Out (amount) {
+            const s = 1.70158;
+            return amount === 0 ? 0 : --amount * amount * ((s + 1) * amount + s) + 1;
+        },
+        InOut (amount) {
+            const s = 1.70158 * 1.525;
+            if ((amount *= 2) < 1) {
+                return 0.5 * (amount * amount * ((s + 1) * amount - s));
+            }
+            return 0.5 * ((amount -= 2) * amount * ((s + 1) * amount + s) + 2);
+        }
+    }),
+    Bounce: Object.freeze({
+        In (amount) {
+            return 1 - Easing.Bounce.Out(1 - amount);
+        },
+        Out (amount) {
+            if (amount < 1 / 2.75) {
+                return 7.5625 * amount * amount;
+            } else if (amount < 2 / 2.75) {
+                return 7.5625 * (amount -= 1.5 / 2.75) * amount + 0.75;
+            } else if (amount < 2.5 / 2.75) {
+                return 7.5625 * (amount -= 2.25 / 2.75) * amount + 0.9375;
+            } else {
+                return 7.5625 * (amount -= 2.625 / 2.75) * amount + 0.984375;
+            }
+        },
+        InOut (amount) {
+            if (amount < 0.5) {
+                return Easing.Bounce.In(amount * 2) * 0.5;
+            }
+            return Easing.Bounce.Out(amount * 2 - 1) * 0.5 + 0.5;
+        }
+    }),
+    generatePow (power = 4) {
+        power = power < Number.EPSILON ? Number.EPSILON : power;
+        power = power > 10000 ? 10000 : power;
+        return {
+            In (amount) {
+                return amount ** power;
+            },
+            Out (amount) {
+                return 1 - (1 - amount) ** power;
+            },
+            InOut (amount) {
+                if (amount < 0.5) {
+                    return (amount * 2) ** power / 2;
+                }
+                return (1 - (2 - amount * 2) ** power) / 2 + 0.5;
+            }
+        };
+    }
+});
+
+class ClassProperties {
+    property(propertyKey, options = {}) {
+        this._properties[propertyKey] = options;
+        return this;
+    }
+    applyProperties(target) {
+        Object.assign(target, this._properties);
+        return target;
+    }
+    constructor(clsName){
+        this.clsName = clsName;
+        this._properties = Object.create(null);
+    }
+}
+class PropertyManager {
+    static _hasProperties(constructor) {
+        return PropertyManager._propertyMap.has(constructor);
+    }
+    static _getProperties(constructor, autoAdd = true) {
+        let props = PropertyManager._propertyMap.get(constructor);
+        if (props === undefined && autoAdd) {
+            props = Object.create(null);
+            PropertyManager._propertyMap.set(constructor, props);
+        }
+        return props;
+    }
+    static _getMergedProperties(constructor) {
+        let merged = null;
+        while(constructor !== Object.constructor.prototype){
+            let props = PropertyManager._getProperties(constructor, false);
+            if (props) {
+                if (merged === null) {
+                    merged = Object.create(null);
+                }
+                Object.assign(merged, props);
+            }
+            constructor = Object.getPrototypeOf(constructor);
+        }
+        return merged;
+    }
+    static _getClassProperties(clsName, autoAdd = true) {
+        let props = PropertyManager._classMap.get(clsName);
+        if (props === undefined && autoAdd) {
+            props = new ClassProperties(clsName);
+            PropertyManager._classMap.set(clsName, props);
+        }
+        return props;
+    }
+    static _applyClassProperties(clsName, constructor) {
+        let cls = PropertyManager._getClassProperties(clsName, false);
+        if (cls) {
+            return cls.applyProperties(PropertyManager._getProperties(constructor));
+        } else {
+            return PropertyManager._getProperties(constructor, false);
+        }
+    }
+}
+PropertyManager._classMap = new Map();
+PropertyManager._propertyMap = new Map();
+function property(target, propertyKey) {
+    let options = null;
+    function normalized(target, propertyKey) {
+        PropertyManager._getProperties(target.constructor)[propertyKey] = options;
+    }
+    if (target === undefined) {
+        return property({});
+    } else if (typeof propertyKey === "undefined") {
+        options = target;
+        return normalized;
+    } else {
+        options = {};
+        normalized(target, propertyKey);
+    }
+}
+
+const CinestationBlendStyle = {
+    Linear: Easing.Linear.None,
+    QuadraticIn: Easing.Quadratic.In,
+    QuadraticOut: Easing.Quadratic.Out,
+    QuadraticInOut: Easing.Quadratic.InOut
+};
+class CinestationBlendDefinition {
+    constructor(){
+        this.style = CinestationBlendStyle.QuadraticInOut;
+        this.time = 4;
+    }
+}
+__decorate([
+    property({
+        value: CinestationBlendStyle
+    })
+], CinestationBlendDefinition.prototype, "style", void 0);
+__decorate([
+    property
+], CinestationBlendDefinition.prototype, "time", void 0);
+
+class ObjectInstance {
+    constructor(){
+        this.instanceId = ObjectInstance._instanceCount++;
+        this.uuid = MathUtils.generateUUID();
+        this.name = "";
+        this.type = "ObjectInstance";
+    }
+}
+ObjectInstance._instanceCount = 0;
+
+function applyProps(target, props) {
+    for(let k in props){
+        let prop = props[k];
+        if (prop === undefined) {
+            continue;
+        }
+        if (target[k] !== undefined) {
+            let des = Object.getOwnPropertyDescriptor(target, k);
+            if (!des || des.writable || des.set) {
+                target[k] = prop;
+            } else {
+                let value = target[k];
+                if (value && value.copy) {
+                    value.copy(prop);
+                }
+            }
+        }
+    }
+    return target;
+}
+function find(node, path) {
+    let child = null;
+    let parts = path.split("/");
+    let children = node.children;
+    for (let part of parts){
+        child = children.find((v)=>v.name === part);
+        if (child) {
+            children = child.children;
+        } else {
+            return null;
+        }
+    }
+    return child;
+}
+function getChildren(node, filter, group = false) {
+    const queue = [
+        node
+    ];
+    const objects = [];
+    while(queue.length !== 0){
+        let object = queue.shift();
+        let target = filter(object);
+        if (target) {
+            objects.push(object);
+            if (!group) {
+                break;
+            }
+        }
+        object.children.forEach((v)=>queue.push(v));
+    }
+    if (group) {
+        return objects;
+    }
+    return objects[0];
+}
+function getChildByName(node, name) {
+    return getChildren(node, (v)=>v && v.name === name);
+}
+const __emtpyObject = {};
+function queryValues(object, name, group = false) {
+    if (name) {
+        if (group) {
+            return Object.values(object || __emtpyObject).filter((v)=>v.name === name);
+        }
+        return Object.values(object || __emtpyObject).find((v)=>v.name === name);
+    }
+    return Object.values(object);
+}
+
+class Component extends ObjectInstance {
+    get enabled() {
+        return this._enabled;
+    }
+    set enabled(v) {
+        if (this._enabled !== v) {
+            this._enabled = v;
+            this.manager.componentScheduler.enableComponent(this, v);
+        }
+    }
+    _onPreDestroy() {
+        this.unscheduleAll();
+        this.manager.removeComponent(this.node, this);
+        if (this._enabled) {
+            this.manager.componentScheduler.enableComponent(this, false);
+        }
+        if (this.onDestroy && this.flags.OnLoadCalled) {
+            this.onDestroy();
+        }
+    }
+    schedule(callback, interval, repeat = -1) {
+        this.manager.scheduler.schedule(this, callback, interval, repeat);
+    }
+    unshedule(callback) {
+        this.manager.scheduler.unshedule(this, callback);
+    }
+    unscheduleAll() {
+        this.manager.scheduler.unscheduleAll(this);
+    }
+    destroy() {
+        if (this.flags.Destroyed) {
+            return false;
+        }
+        this.destroyImmediate();
+        return true;
+    }
+    destroyImmediate() {
+        if (this._onPreDestroy) {
+            this._onPreDestroy();
+        }
+        this.flags.Destroyed = true;
+    }
+    apply(props) {
+        return applyProps(this, props);
+    }
+    constructor(...args){
+        super(...args);
+        this._enabled = true;
+        this.isComponent = true;
+        this.type = "Component";
+        this.flags = {};
+    }
+}
+
+const { clamp: clamp$1, lerp } = MathUtils;
+class CinestationBrain extends Component {
+    get vcam() {
+        return this._vcam;
+    }
+    get vcams() {
+        return this._vcams;
+    }
+    lastUpdate(dt) {
+        let vcam = this.getActiveCamera();
+        if (vcam == null) return;
+        this._vcams.forEach((v)=>{
+            if (!v.locked) {
+                v.enabled = v === vcam;
+            }
+        });
+        if (this._lerpTime < this.brainBlend.time) {
+            this._lerpTime += dt;
+            let t = clamp$1(this._lerpTime / this.brainBlend.time, 0, 1);
+            this._lerpToMainCamera(vcam, this.brainBlend.style(t));
+        } else {
+            this._lerpToMainCamera(vcam, 1);
+        }
+    }
+    activeCamera(vcam, time = 4) {
+        if (this._vcamSolo !== vcam) {
+            this._vcamSolo = vcam;
+            this._lerpTime = 0;
+            this.brainBlend.time = time;
+        }
+    }
+    addCamera(vcam) {
+        let index = this._vcams.indexOf(vcam);
+        if (index === -1) {
+            this._vcams.push(vcam);
+        }
+    }
+    removeCamera(vcam) {
+        let index = this._vcams.indexOf(vcam);
+        if (index !== -1) {
+            this._vcams.splice(index, 1);
+        }
+    }
+    getActiveCamera() {
+        return this._vcamSolo || this._vcams.filter((v)=>v.enabled || v.locked).sort((a, b)=>b.priority - a.priority)[0];
+    }
+    _lerpToMainCamera(vcam, t) {
+        const from = this.node, to = vcam;
+        const { lens, finalPosition, finalRotation } = to;
+        const isLensChanged = from.fov != lens.fov || from.near != lens.near || from.far != lens.far;
+        from.position.lerp(finalPosition, t);
+        from.quaternion.slerp(finalRotation, t);
+        from.fov = lerp(from.fov, lens.fov, t);
+        from.near = lens.near;
+        from.far = lens.far;
+        if (isLensChanged) {
+            from.updateProjectionMatrix();
+        }
+    }
+    constructor(...args){
+        super(...args);
+        this._vcam = null;
+        this._vcamSolo = null;
+        this._vcams = [];
+        this._lerpTime = 4;
+        this.brainBlend = new CinestationBlendDefinition();
+    }
+}
+__decorate([
+    property
+], CinestationBrain.prototype, "brainBlend", void 0);
+
+class Lens {
+    constructor(){
+        this.fov = 45;
+        this.near = 0.1;
+        this.far = 1000;
+    }
+}
+__decorate([
+    property
+], Lens.prototype, "fov", void 0);
+__decorate([
+    property
+], Lens.prototype, "near", void 0);
+__decorate([
+    property
+], Lens.prototype, "far", void 0);
+class VirtualCamera extends Component {
+    get finalPosition() {
+        return this._finalPosition.copy(this.node.position).add(this.correctPosition);
+    }
+    get finalRotation() {
+        return this._finalRotation.copy(this.node.quaternion).multiply(this.correctRotation);
+    }
+    onLoad() {
+        const camera = this.viewer.camera;
+        this.node.isCamera = true;
+        this.lens.fov = camera.fov;
+        this.lens.near = camera.near;
+        this.lens.far = camera.far;
+        this.brain = this.manager.getComponent(camera, CinestationBrain, true);
+        this.brain.addCamera(this);
+    }
+    onDestroy() {
+        this.brain.removeCamera(this);
+    }
+    constructor(...args){
+        super(...args);
+        this._finalPosition = new Vector3();
+        this._finalRotation = new Quaternion();
+        this.locked = false;
+        this.priority = 10;
+        this.lens = new Lens();
+        this.correctPosition = new Vector3();
+        this.correctRotation = new Quaternion();
+    }
+}
+__decorate([
+    property
+], VirtualCamera.prototype, "lens", void 0);
+
+const PressState = {
+    NONE: 1 << 0,
+    SELECTED: 1 << 1,
+    IN: 1 << 2
+};
+class Pressability {
+    connect(target) {
+        let connector = this._connectors.find((v)=>v.target === target);
+        if (connector === undefined) {
+            connector = {
+                target,
+                state: PressState.NONE
+            };
+            this._connectors.push(connector);
+        }
+    }
+    disconnect(target) {
+        let index = this._connectors.findIndex((v)=>v.target === target);
+        if (index !== -1) {
+            this._connectors.splice(index, 1);
+        }
+    }
+    pointerDown(pointer, camera) {
+        if (this._connectors.length === 0) return;
+        this._raycaster.setFromCamera(pointer, camera);
+        for (let conn of this._connectors){
+            if (conn.target.has("click") || conn.target.has("pointerdown")) {
+                let intersects = this._raycaster.intersectObject(conn.target.node, true);
+                if (intersects.length) {
+                    conn.state |= PressState.SELECTED;
+                    conn.target.emit("pointerdown", {
+                        intersects
+                    });
+                }
+            }
+        }
+    }
+    pointerUp(pointer, camera) {
+        if (this._connectors.length === 0) return;
+        this._raycaster.setFromCamera(pointer, camera);
+        for (let conn of this._connectors){
+            if (conn.target.has("click") || conn.target.has("pointerup")) {
+                let intersects = this._raycaster.intersectObject(conn.target.node, true);
+                if (intersects.length) {
+                    if (conn.state & PressState.SELECTED) {
+                        conn.state &= ~PressState.SELECTED;
+                        conn.target.emit("click", {
+                            intersects
+                        });
+                    }
+                    conn.target.emit("pointerup", {
+                        intersects
+                    });
+                }
+            }
+        }
+    }
+    pointerMove(pointer, camera) {
+        if (this._connectors.length === 0) return;
+        this._raycaster.setFromCamera(pointer, camera);
+        for (let conn of this._connectors){
+            if (conn.target.has("pointerover") || conn.target.has("pointerout")) {
+                let intersects = this._raycaster.intersectObject(conn.target.node, true);
+                if (intersects.length) {
+                    if (!(conn.state & PressState.IN)) {
+                        conn.state |= PressState.IN;
+                        conn.target.emit("pointerover", {
+                            intersects
+                        });
+                    }
+                } else {
+                    if (conn.state & PressState.IN) {
+                        conn.state &= ~PressState.IN;
+                        conn.target.emit("pointerout", {
+                            intersects
+                        });
+                    }
+                }
+            }
+        }
+    }
+    constructor(){
+        this._raycaster = new Raycaster();
+        this._connectors = [];
+    }
+}
+
+class DeviceInput {
+    get pointerButton() {
+        return this._pointerButton;
+    }
+    get pointer() {
+        return this._pointer;
+    }
+    get pointerPosition() {
+        return this._pointerPosition;
+    }
+    get mouseWheel() {
+        return this._mouseWheel;
+    }
+    get touchCount() {
+        return this._touchCount;
+    }
+    get touches() {
+        return this._touches;
+    }
+    get keys() {
+        return this._keys;
+    }
+    addEventListeners() {
+        const { canvas } = this.viewer;
+        canvas.style.touchAction = 'none';
+        this._addEventListener(canvas, 'contextmenu', (e)=>e.preventDefault());
+        this._addEventListener(canvas, "pointerdown", (e)=>this._onPointerDown(e), {
+            passive: false
+        });
+        this._addEventListener(canvas, "pointerup", (e)=>this._onPointerUp(e), {
+            passive: false
+        });
+        this._addEventListener(canvas, "pointercancel", (e)=>this._onPointerUp(e), {
+            passive: false
+        });
+        this._addEventListener(canvas, "pointerout", (e)=>this._onPointerUp(e), {
+            passive: false
+        });
+        this._addEventListener(canvas, "pointermove", (e)=>this._onPointerMove(e), {
+            passive: true
+        });
+        this._addEventListener(canvas, "wheel", (e)=>this._onMouseWheel(e), {
+            passive: false
+        });
+        this._addEventListener(canvas, "touchstart", (e)=>this._onTouchStart(e), {
+            passive: true
+        });
+        this._addEventListener(canvas, "touchend", (e)=>this._onTouchEnd(e), {
+            passive: true
+        });
+        this._addEventListener(canvas, "touchmove", (e)=>this._onTouchMove(e), {
+            passive: true
+        });
+        //监听了pointer事件之后，key事件失效，改成window解决
+        this._addEventListener(window, "keydown", (e)=>this._onKeyDown(e), {
+            passive: false
+        });
+        this._addEventListener(window, "keypress", (e)=>this._onKeyPress(e), {
+            passive: false
+        });
+        this._addEventListener(window, "keyup", (e)=>this._onKeyUp(e), {
+            passive: false
+        });
+        this._addEventListener(window, "resize", (e)=>this._onResize(e), {
+            passive: false
+        });
+    }
+    removeAllListeners() {
+        for (let { target, type, callback } of this._listeners){
+            if (target.removeEventListener) target.removeEventListener(type, callback);
+            else if (target.off) target.off(type, callback, target);
+        }
+        this._listeners = [];
+    }
+    connect(target, event) {
+        switch(event){
+            case DeviceInput.CLICK:
+            case DeviceInput.POINTER_DOWN:
+            case DeviceInput.POINTER_UP:
+            case DeviceInput.POINTER_OVER:
+            case DeviceInput.POINTER_OUT:
+                this._pressability.connect(target);
+                break;
+        }
+    }
+    disconnect(target) {
+        this._pressability.disconnect(target);
+    }
+    _addEventListener(target, type, callback, options) {
+        if (target.addEventListener) target.addEventListener(type, callback, options);
+        else if (target.on) target.on(type, callback, target);
+        this._listeners.push({
+            target,
+            type,
+            callback
+        });
+    }
+    _onResize(e) {
+        this.viewer.rotate();
+        this.viewer.resize();
+    }
+    _remapPointer(e) {
+        const width = this.viewer.width;
+        return this.viewer.rootRotated ? {
+            button: e.button,
+            buttons: e.buttons,
+            clientX: e.clientY,
+            clientY: width - e.clientX,
+            offsetX: e.offsetY,
+            offsetY: width - e.offsetX,
+            pageX: e.pageY,
+            pageY: width - e.pageX,
+            screenX: e.screenY,
+            screenY: width - e.screenX,
+            movementX: e.movementY,
+            movementY: e.movementX
+        } : e;
+    }
+    _remapTouch(e) {
+        const width = this.viewer.width;
+        return this.viewer.rootRotated ? {
+            touches: Array.from(e.touches).map((v)=>{
+                return {
+                    identifier: v.identifier,
+                    clientX: v.clientY,
+                    clientY: width - v.clientX,
+                    pageX: v.pageY,
+                    pageY: width - v.pageX,
+                    screenX: v.screenY,
+                    screenY: width - v.screenX
+                };
+            })
+        } : e;
+    }
+    _computePointer(e) {
+        this._pointer.x = e.offsetX / this.viewer.width * 2 - 1;
+        this._pointer.y = 1 - e.offsetY / this.viewer.height * 2;
+        this._pointerPosition.set(e.offsetX, e.offsetY);
+    }
+    _onPointerDown(e) {
+        e.preventDefault();
+        e = this._remapPointer(e);
+        this._pointerButton = e.button;
+        this._computePointer(e);
+        this._pressability.pointerDown(this._pointer, this.viewer.camera);
+        this.viewer.emit(DeviceInput.POINTER_DOWN, e);
+    }
+    _onPointerUp(e) {
+        e.preventDefault();
+        e = this._remapPointer(e);
+        this._pointerButton = -1;
+        this._computePointer(e);
+        this._pressability.pointerUp(this._pointer, this.viewer.camera);
+        this.viewer.emit(DeviceInput.POINTER_UP, e);
+    }
+    _onPointerMove(e) {
+        e = this._remapPointer(e);
+        this._computePointer(e);
+        this._pressability.pointerMove(this._pointer, this.viewer.camera);
+        this.viewer.emit(DeviceInput.POINTER_MOVE, e);
+    }
+    _onMouseWheel(e) {
+        e.preventDefault();
+        this._mouseWheel = e.deltaY || e.wheelDelta;
+        this.viewer.emit(DeviceInput.MOUSE_WHEEL, e);
+    }
+    _onTouchStart(e) {
+        e = this._remapTouch(e);
+        this.viewer.emit(DeviceInput.TOUCH_START, e);
+    }
+    _onTouchEnd(e) {
+        e = this._remapTouch(e);
+        this.viewer.emit(DeviceInput.TOUCH_END, e);
+    }
+    _onTouchMove(e) {
+        e = this._remapTouch(e);
+        let touches = e.touches;
+        let touchesTo = this._touches;
+        for(let i = touches.length; i--;){
+            if (touchesTo[i] == undefined) {
+                touchesTo[i] = {
+                    id: -1,
+                    position: new Vector2()
+                };
+            }
+            const touch = touches[i];
+            touchesTo[i].id = touch.identifier;
+            touchesTo[i].position.set(touch.pageX, touch.pageY);
+        }
+        this._touchCount = touches.length;
+        this.viewer.emit(DeviceInput.TOUCH_MOVE, e);
+    }
+    _onKeyDown(e) {
+        this._keys[e.key] = true;
+        this.viewer.emit(DeviceInput.KEYDOWN, e);
+    }
+    _onKeyPress(e) {
+        this._keys[e.key] = true;
+        this.viewer.emit(DeviceInput.KEYPRESS, e);
+    }
+    _onKeyUp(e) {
+        this._keys[e.key] = false;
+        this.viewer.emit(DeviceInput.KEYUP, e);
+    }
+    constructor(viewer){
+        this.viewer = viewer;
+        this._listeners = [];
+        this._mouseWheel = 0;
+        this._touches = [];
+        this._touchCount = 0;
+        this._pointerButton = -1;
+        this._pointerPosition = new Vector2();
+        this._pointer = new Vector2();
+        this._keys = {};
+        this._pressability = new Pressability();
+    }
+}
+DeviceInput.CLICK = "click";
+DeviceInput.MOUSE_WHEEL = "mousewheel";
+DeviceInput.TOUCH_START = "touchstart";
+DeviceInput.TOUCH_END = "touchend";
+DeviceInput.TOUCH_MOVE = "touchmove";
+DeviceInput.POINTER_DOWN = "pointerdown";
+DeviceInput.POINTER_UP = "pointerup";
+DeviceInput.POINTER_MOVE = "pointermove";
+DeviceInput.POINTER_OVER = "pointerover";
+DeviceInput.POINTER_OUT = "pointerout";
+DeviceInput.KEYDOWN = "keydown";
+DeviceInput.KEYPRESS = "keypress";
+DeviceInput.KEYUP = "keyup";
+
+const isSSR$1 = typeof window === 'undefined';
+class DetectUA {
+    /**
+     * Match entry based on position found in the user-agent string
+     *
+     * @param pattern regular expression pattern
+     */ match(position, pattern) {
+        const match = this.userAgent.match(pattern);
+        return match && match.length > 1 && match[position] || '';
+    }
+    /**
+     * Returns if the device is a mobile device
+     */ get isMobile() {
+        return(// Default mobile
+        !this.isTablet && (/[^-]mobi/i.test(this.userAgent) || // iPhone / iPod
+        this.iOSDevice === 'iphone' || this.iOSDevice === 'ipod' || // Android
+        this.isAndroidDevice || // Nexus mobile
+        /nexus\s*[0-6]\s*/i.test(this.userAgent)));
+    }
+    /**
+     * Returns if the device is a tablet device
+     */ get isTablet() {
+        return(// Default tablet
+        /tablet/i.test(this.userAgent) && !/tablet pc/i.test(this.userAgent) || // iPad
+        this.iOSDevice === 'ipad' || // Android
+        this.isAndroidDevice && !/[^-]mobi/i.test(this.userAgent) || // Nexus tablet
+        !/nexus\s*[0-6]\s*/i.test(this.userAgent) && /nexus\s*[0-9]+/i.test(this.userAgent));
+    }
+    /**
+     * Returns if the device is a desktop device
+     */ get isDesktop() {
+        return !this.isMobile && !this.isTablet;
+    }
+    /**
+     * Returns if the device is running MacOS (and if so which version)
+     *
+     * '5' => Leopard'
+     * '6' => Snow Leopard'
+     * '7' => Lion'
+     * '8' => Mountain Lion'
+     * '9' => Mavericks'
+     * '10' => Yosemite'
+     * '11' => El Capitan'
+     * '12' => Sierra'
+     * '13' => High Sierra'
+     * '14' => Mojave'
+     * '15' => Catalina'
+     */ get isMacOS() {
+        return /macintosh/i.test(this.userAgent) && {
+            version: this.match(1, /mac os x (\d+(\.?_?\d+)+)/i).replace(/[_\s]/g, '.').split('.').map((versionNumber)=>versionNumber)[1]
+        };
+    }
+    /**
+     * Returns if the device is running Windows (and if so which version)
+     *
+     * 'NT' => 'NT'
+     * 'XP' => 'XP'
+     * 'NT 5.0' => '2000'
+     * 'NT 5.1' => 'XP'
+     * 'NT 5.2' => '2003'
+     * 'NT 6.0' => 'Vista'
+     * 'NT 6.1' => '7'
+     * 'NT 6.2' => '8'
+     * 'NT 6.3' => '8.1'
+     * 'NT 10.0' => '10'
+     */ get isWindows() {
+        return /windows /i.test(this.userAgent) && {
+            version: this.match(1, /Windows ((NT|XP)( \d\d?.\d)?)/i)
+        };
+    }
+    /**
+     * Returns if the device is an iOS device (and if so which version)
+     */ get isiOS() {
+        return !!this.iOSDevice && {
+            version: this.match(1, /os (\d+([_\s]\d+)*) like mac os x/i).replace(/[_\s]/g, '.') || this.match(1, /version\/(\d+(\.\d+)?)/i)
+        };
+    }
+    /**
+     * Returns if the device is an Android device (and if so which version)
+     */ get isAndroid() {
+        return this.isAndroidDevice && {
+            version: this.match(1, /android[ \/-](\d+(\.\d+)*)/i)
+        };
+    }
+    /**
+     * Returns the browser name and version
+     */ get browser() {
+        const versionIdentifier = this.match(1, /version\/(\d+(\.\d+)?)/i);
+        if (/opera/i.test(this.userAgent)) {
+            // Opera
+            return {
+                name: 'Opera',
+                version: versionIdentifier || this.match(1, /(?:opera|opr|opios)[\s\/](\d+(\.\d+)?)/i)
+            };
+        } else if (/opr\/|opios/i.test(this.userAgent)) {
+            // Opera
+            return {
+                name: 'Opera',
+                version: this.match(1, /(?:opr|opios)[\s\/](\d+(\.\d+)?)/i) || versionIdentifier
+            };
+        } else if (/SamsungBrowser/i.test(this.userAgent)) {
+            // Samsung Browser
+            return {
+                name: 'Samsung Internet for Android',
+                version: versionIdentifier || this.match(1, /(?:SamsungBrowser)[\s\/](\d+(\.\d+)?)/i)
+            };
+        } else if (/yabrowser/i.test(this.userAgent)) {
+            // Yandex Browser
+            return {
+                name: 'Yandex Browser',
+                version: versionIdentifier || this.match(1, /(?:yabrowser)[\s\/](\d+(\.\d+)?)/i)
+            };
+        } else if (/ucbrowser/i.test(this.userAgent)) {
+            // UC Browser
+            return {
+                name: 'UC Browser',
+                version: this.match(1, /(?:ucbrowser)[\s\/](\d+(\.\d+)?)/i)
+            };
+        } else if (/msie|trident/i.test(this.userAgent)) {
+            // Internet Explorer
+            return {
+                name: 'Internet Explorer',
+                version: this.match(1, /(?:msie |rv:)(\d+(\.\d+)?)/i)
+            };
+        } else if (/(edge|edgios|edga|edg)/i.test(this.userAgent)) {
+            // Edge
+            return {
+                name: 'Microsoft Edge',
+                version: this.match(2, /(edge|edgios|edga|edg)\/(\d+(\.\d+)?)/i)
+            };
+        } else if (/firefox|iceweasel|fxios/i.test(this.userAgent)) {
+            // Firefox
+            return {
+                name: 'Firefox',
+                version: this.match(1, /(?:firefox|iceweasel|fxios)[ \/](\d+(\.\d+)?)/i)
+            };
+        } else if (/chromium/i.test(this.userAgent)) {
+            // Chromium
+            return {
+                name: 'Chromium',
+                version: this.match(1, /(?:chromium)[\s\/](\d+(?:\.\d+)?)/i) || versionIdentifier
+            };
+        } else if (/chrome|crios|crmo/i.test(this.userAgent)) {
+            // Chrome
+            return {
+                name: 'Chrome',
+                version: this.match(1, /(?:chrome|crios|crmo)\/(\d+(\.\d+)?)/i)
+            };
+        } else if (/safari|applewebkit/i.test(this.userAgent)) {
+            // Safari
+            return {
+                name: 'Safari',
+                version: versionIdentifier
+            };
+        } else {
+            // Everything else
+            return {
+                name: this.match(1, /^(.*)\/(.*) /),
+                version: this.match(2, /^(.*)\/(.*) /)
+            };
+        }
+    }
+    /**
+     * Detect a users browser, browser version and whether it is a mobile-, tablet- or desktop device
+     *
+     * @param forceUserAgent Force a user agent string (useful for testing)
+     */ constructor(forceUserAgent){
+        this.userAgent = forceUserAgent ? forceUserAgent : !isSSR$1 && window.navigator ? window.navigator.userAgent : '';
+        this.isAndroidDevice = !/like android/i.test(this.userAgent) && /android/i.test(this.userAgent);
+        this.iOSDevice = this.match(1, /(iphone|ipod|ipad)/i).toLowerCase();
+        // Workaround for ipadOS, force detection as tablet
+        // SEE: https://github.com/lancedikson/bowser/issues/329
+        // SEE: https://stackoverflow.com/questions/58019463/how-to-detect-device-name-in-safari-on-ios-13-while-it-doesnt-show-the-correct
+        if (!isSSR$1 && navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 2 && !window.MSStream) {
+            this.iOSDevice = 'ipad';
+        }
+    }
+}
+
+const isSSR = typeof window === 'undefined';
+const detectUA = new DetectUA();
+const userAgent = (navigator.userAgent || navigator.vendor).toLowerCase();
+const browserName = typeof detectUA.browser === "boolean" ? "" : detectUA.browser.name;
+class SystemInfo {
+}
+SystemInfo.isTablet = detectUA.isTablet;
+SystemInfo.isMobile = detectUA.isMobile || detectUA.isTablet;
+SystemInfo.isDesktop = detectUA.isDesktop;
+SystemInfo.device = SystemInfo.isMobile ? "mobile" : "desktop";
+SystemInfo.isAndroid = !!detectUA.isAndroid;
+SystemInfo.isIOS = !!detectUA.isiOS;
+SystemInfo.isMacOS = !!detectUA.isMacOS;
+SystemInfo.isWindows = typeof detectUA.isWindows === "boolean" ? detectUA.isWindows : detectUA.isWindows.version !== null;
+SystemInfo.isLinux = userAgent.indexOf("linux") != -1;
+SystemInfo.ua = userAgent;
+SystemInfo.isEdge = browserName === "Microsoft Edge";
+SystemInfo.isIE = browserName === "Internet Explorer";
+SystemInfo.isFirefox = browserName === "Firefox";
+SystemInfo.isChrome = browserName === "Chrome";
+SystemInfo.isOpera = browserName === "Opera";
+SystemInfo.isSafari = browserName === "Safari";
+SystemInfo.isSupportMSAA = !userAgent.match("version/15.4 ");
+SystemInfo.cpuCoreCount = navigator.hardwareConcurrency || 1;
+SystemInfo.isRetina = !isSSR && window.devicePixelRatio && window.devicePixelRatio >= 1.5;
+SystemInfo.isIFrame = !isSSR && window.self !== window.top;
+
 const { clamp, degToRad } = MathUtils;
 const { abs, tan, PI } = Math;
 const PI2 = PI * 2;
@@ -3255,75 +2682,6 @@ class Animation extends Component {
     }
 }
 
-function applyProps(target, props) {
-    for(let k in props){
-        let prop = props[k];
-        if (prop === undefined) {
-            continue;
-        }
-        if (target[k] !== undefined) {
-            let des = Object.getOwnPropertyDescriptor(target, k);
-            if (!des || des.writable || des.set) {
-                target[k] = prop;
-            } else {
-                let value = target[k];
-                if (value && value.copy) {
-                    value.copy(prop);
-                }
-            }
-        }
-    }
-    return target;
-}
-function find(node, path) {
-    let child = null;
-    let parts = path.split("/");
-    let children = node.children;
-    for (let part of parts){
-        child = children.find((v)=>v.name === part);
-        if (child) {
-            children = child.children;
-        } else {
-            return null;
-        }
-    }
-    return child;
-}
-function getChildren(node, filter, group = false) {
-    const queue = [
-        node
-    ];
-    const objects = [];
-    while(queue.length !== 0){
-        let object = queue.shift();
-        let target = filter(object);
-        if (target) {
-            objects.push(object);
-            if (!group) {
-                break;
-            }
-        }
-        object.children.forEach((v)=>queue.push(v));
-    }
-    if (group) {
-        return objects;
-    }
-    return objects[0];
-}
-function getChildByName(node, name) {
-    return getChildren(node, (v)=>v && v.name === name);
-}
-const __emtpyObject = {};
-function queryValues(object, name, group = false) {
-    if (name) {
-        if (group) {
-            return Object.values(object || __emtpyObject).filter((v)=>v.name === name);
-        }
-        return Object.values(object || __emtpyObject).find((v)=>v.name === name);
-    }
-    return Object.values(object);
-}
-
 class ContactShadows extends Component {
     get visible() {
         return this.node.visible;
@@ -3435,6 +2793,321 @@ __decorate([
     })
 ], ContactShadows.prototype, "blur", void 0);
 
+const getVersion = ()=>parseInt(REVISION.replace(/\D+/g, ''));
+const version = /* @__PURE__ */ getVersion();
+
+class DiscardMaterial extends ShaderMaterial {
+    constructor(...args){
+        super(...args);
+        this.vertexShader = 'void main() { }';
+        this.fragmentShader = 'void main() { gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0); discard;  }';
+    }
+}
+
+function shaderMaterial(uniforms, vertexShader, fragmentShader) {
+    var _class;
+    return _class = class extends THREE.ShaderMaterial {
+        constructor(parameters){
+            super({
+                vertexShader,
+                fragmentShader
+            });
+            for(const key in uniforms){
+                this.uniforms[key] = new THREE.Uniform(uniforms[key]);
+                Object.defineProperty(this, key, {
+                    get () {
+                        return this.uniforms[key].value;
+                    },
+                    set (value) {
+                        this.uniforms[key].value = value;
+                    }
+                });
+            }
+            this.uniforms = THREE.UniformsUtils.clone(this.uniforms);
+            this.setValues(parameters);
+        }
+    }, _class.key = THREE.MathUtils.generateUUID(), _class;
+}
+
+class AccumulativeShadows extends Component {
+    constructor({ temporal, frames = 40, limit = Infinity, blend = 20, scale = 10, opacity = 1, alphaTest = 0.75, color = 'black', colorBlend = 2, resolution = 1024, toneMapped = true, randomLights = [], ...props } = {}){
+        super();
+        this.temporal = false;
+        this.frames = 1;
+        this.count = 0;
+        this.limit = Infinity;
+        this.blend = 2;
+        this.temporal = !!temporal;
+        this.frames = Math.max(2, frames);
+        this.blend = Math.max(2, frames === Infinity ? blend : frames);
+        this.count = 0;
+        this.node = applyProps(new THREE.Group(), props);
+        this.onLoad = ()=>{
+            const { viewer } = this;
+            const { renderer, scene, camera } = viewer;
+            const plm = new ProgressiveLightMap(renderer, scene, resolution);
+            const gPlane = viewer.add(Plane, {
+                parent: this.node,
+                receiveShadow: true,
+                scale: new THREE.Vector3(scale, scale, scale),
+                rotation: new THREE.Euler(-Math.PI / 2, 0, 0),
+                material: new SoftShadowMaterial({
+                    color,
+                    toneMapped,
+                    transparent: true,
+                    depthWrite: false,
+                    blend: colorBlend,
+                    map: plm.progressiveLightMap2.texture
+                })
+            });
+            plm.configure(gPlane);
+            const gLights = viewer.add(THREE.Group, {
+                parent: this.node
+            });
+            gLights.traverse = ()=>null;
+            randomLights.forEach((light)=>gLights.add(light));
+            const update = (frames = 1)=>{
+                // Adapt the opacity-blend ratio to the number of frames
+                const material = gPlane.material;
+                if (!this.temporal) {
+                    material.opacity = opacity;
+                    material.alphaTest = alphaTest;
+                } else {
+                    material.opacity = Math.min(opacity, material.opacity + opacity / this.blend);
+                    material.alphaTest = Math.min(alphaTest, material.alphaTest + alphaTest / this.blend);
+                }
+                // Switch accumulative lights on
+                gLights.visible = true;
+                // Collect scene lights and meshes
+                plm.prepare();
+                // Update the lightmap and the accumulative lights
+                for(let i = 0; i < frames; i++){
+                    randomLights.forEach((light)=>light.update());
+                    plm.update(camera, this.blend);
+                }
+                // Switch lights off
+                gLights.visible = false;
+                // Restore lights and meshes
+                plm.finish();
+            };
+            const reset = ()=>{
+                // Clear buffers, reset opacities, set frame count to 0
+                plm.clear();
+                const material = gPlane.material;
+                material.opacity = 0;
+                material.alphaTest = 0;
+                this.count = 0;
+            };
+            this.start = ()=>{
+                // Reset internals, buffers, ...
+                reset();
+                // Update lightmap
+                if (!this.temporal && this.frames !== Infinity) update(this.blend);
+            };
+            this.update = ()=>{
+                if ((this.temporal || this.frames === Infinity) && this.count < this.frames && this.count < this.limit) {
+                    update();
+                    this.count++;
+                }
+            };
+        };
+    }
+}
+class RandomizedLight extends THREE.Group {
+    constructor({ castShadow = true, bias = 0.001, mapSize = 512, size = 5, near = 0.5, far = 500, frames = 1, position = new THREE.Vector3(), radius = 1, amount = 8, intensity = version >= 155 ? Math.PI : 1, ambient = 0.5, ...props } = {}){
+        super();
+        applyProps(this, props);
+        const length = position.length();
+        for(let i = 0; i < amount; i++){
+            const light = new THREE.DirectionalLight();
+            light.shadow.bias = bias;
+            light.shadow.mapSize.set(mapSize, mapSize);
+            light.shadow.camera = new THREE.OrthographicCamera(-size, size, size, -size, near, far);
+            light.castShadow = castShadow;
+            light.intensity = intensity / amount;
+            this.add(light);
+        }
+        this.update = ()=>{
+            for (let light of this.children){
+                if (Math.random() > ambient) {
+                    light.position.set(position.x + THREE.MathUtils.randFloatSpread(radius), position.y + THREE.MathUtils.randFloatSpread(radius), position.z + THREE.MathUtils.randFloatSpread(radius));
+                } else {
+                    const lambda = Math.acos(2 * Math.random() - 1) - Math.PI / 2.0;
+                    const phi = 2 * Math.PI * Math.random();
+                    light.position.set(Math.cos(lambda) * Math.cos(phi) * length, Math.abs(Math.cos(lambda) * Math.sin(phi) * length), Math.sin(lambda) * length);
+                }
+            }
+        };
+    }
+}
+const SoftShadowMaterial = shaderMaterial({
+    color: new THREE.Color(),
+    blend: 2.0,
+    alphaTest: 0.75,
+    opacity: 0,
+    map: null
+}, `varying vec2 vUv;
+   void main() {
+     gl_Position = projectionMatrix * viewMatrix * modelMatrix * vec4(position, 1.);
+     vUv = uv;
+   }`, `varying vec2 vUv;
+   uniform sampler2D map;
+   uniform vec3 color;
+   uniform float opacity;
+   uniform float alphaTest;
+   uniform float blend;
+   void main() {
+     vec4 sampledDiffuseColor = texture2D(map, vUv);
+     gl_FragColor = vec4(color * sampledDiffuseColor.r * blend, max(0.0, (1.0 - (sampledDiffuseColor.r + sampledDiffuseColor.g + sampledDiffuseColor.b) / alphaTest)) * opacity);
+     #include <${version >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
+   }`);
+function isLight(object) {
+    return object.isLight;
+}
+function isGeometry(object) {
+    return !!object.geometry;
+}
+class ProgressiveLightMap {
+    clear() {
+        this.renderer.getClearColor(this.clearColor);
+        this.clearAlpha = this.renderer.getClearAlpha();
+        this.renderer.setClearColor('black', 1);
+        this.renderer.setRenderTarget(this.progressiveLightMap1);
+        this.renderer.clear();
+        this.renderer.setRenderTarget(this.progressiveLightMap2);
+        this.renderer.clear();
+        this.renderer.setRenderTarget(null);
+        this.renderer.setClearColor(this.clearColor, this.clearAlpha);
+        this.lights = [];
+        this.meshes = [];
+        this.scene.traverse((object)=>{
+            if (isGeometry(object)) {
+                this.meshes.push({
+                    object,
+                    material: object.material
+                });
+            } else if (isLight(object)) {
+                this.lights.push({
+                    object,
+                    intensity: object.intensity
+                });
+            }
+        });
+    }
+    prepare() {
+        this.lights.forEach((light)=>light.object.intensity = 0);
+        this.meshes.forEach((mesh)=>mesh.object.material = this.discardMat);
+    }
+    finish() {
+        this.lights.forEach((light)=>light.object.intensity = light.intensity);
+        this.meshes.forEach((mesh)=>mesh.object.material = mesh.material);
+    }
+    configure(object) {
+        this.object = object;
+    }
+    update(camera, blendWindow = 100) {
+        if (!this.object) return;
+        // Set each object's material to the UV Unwrapped Surface Mapping Version
+        this.averagingWindow.value = blendWindow;
+        this.object.material = this.targetMat;
+        // Ping-pong two surface buffers for reading/writing
+        const activeMap = this.buffer1Active ? this.progressiveLightMap1 : this.progressiveLightMap2;
+        const inactiveMap = this.buffer1Active ? this.progressiveLightMap2 : this.progressiveLightMap1;
+        // Render the object's surface maps
+        const oldBg = this.scene.background;
+        this.scene.background = null;
+        this.renderer.setRenderTarget(activeMap);
+        this.previousShadowMap.value = inactiveMap.texture;
+        this.buffer1Active = !this.buffer1Active;
+        this.renderer.render(this.scene, camera);
+        this.renderer.setRenderTarget(null);
+        this.scene.background = oldBg;
+    }
+    constructor(renderer, scene, res = 1024){
+        this.renderer = renderer;
+        this.res = res;
+        this.scene = scene;
+        this.buffer1Active = false;
+        this.lights = [];
+        this.meshes = [];
+        this.object = null;
+        this.clearColor = new THREE.Color();
+        this.clearAlpha = 0;
+        // Create the Progressive LightMap Texture
+        const textureParams = {
+            type: THREE.HalfFloatType,
+            magFilter: THREE.NearestFilter,
+            minFilter: THREE.NearestFilter
+        };
+        this.progressiveLightMap1 = new THREE.WebGLRenderTarget(this.res, this.res, textureParams);
+        this.progressiveLightMap2 = new THREE.WebGLRenderTarget(this.res, this.res, textureParams);
+        // Inject some spicy new logic into a standard phong material
+        this.discardMat = new DiscardMaterial();
+        this.targetMat = new THREE.MeshLambertMaterial({
+            fog: false
+        });
+        this.previousShadowMap = {
+            value: this.progressiveLightMap1.texture
+        };
+        this.averagingWindow = {
+            value: 100
+        };
+        this.targetMat.onBeforeCompile = (shader)=>{
+            // Vertex Shader: Set Vertex Positions to the Unwrapped UV Positions
+            shader.vertexShader = 'varying vec2 vUv;\n' + shader.vertexShader.slice(0, -1) + 'vUv = uv; gl_Position = vec4((uv - 0.5) * 2.0, 1.0, 1.0); }';
+            // Fragment Shader: Set Pixels to average in the Previous frame's Shadows
+            const bodyStart = shader.fragmentShader.indexOf('void main() {');
+            shader.fragmentShader = 'varying vec2 vUv;\n' + shader.fragmentShader.slice(0, bodyStart) + 'uniform sampler2D previousShadowMap;\n	uniform float averagingWindow;\n' + shader.fragmentShader.slice(bodyStart - 1, -1) + `\nvec3 texelOld = texture2D(previousShadowMap, vUv).rgb;
+                gl_FragColor.rgb = mix(texelOld, gl_FragColor.rgb, 1.0/ averagingWindow);
+            }`;
+            // Set the Previous Frame's Texture Buffer and Averaging Window
+            shader.uniforms.previousShadowMap = this.previousShadowMap;
+            shader.uniforms.averagingWindow = this.averagingWindow;
+        };
+    }
+}
+
+class Center extends Component {
+    constructor({ disable, disableX, disableY, disableZ, left, right, top, bottom, front, back, onCentered, precise = true, cacheKey = 0, children = [], ...props } = {}){
+        super();
+        this.node = applyProps(new Group(), props);
+        this.start = ()=>{
+            const inner = new Group().add(...children);
+            const outer = new Group().add(inner);
+            this.node.add(outer);
+            outer.matrixWorld.identity();
+            const box3 = new Box3().setFromObject(inner, precise);
+            const center = new Vector3();
+            const sphere = new Sphere$1();
+            const width = box3.max.x - box3.min.x;
+            const height = box3.max.y - box3.min.y;
+            const depth = box3.max.z - box3.min.z;
+            box3.getCenter(center);
+            box3.getBoundingSphere(sphere);
+            const vAlign = top ? height / 2 : bottom ? -height / 2 : 0;
+            const hAlign = left ? -width / 2 : right ? width / 2 : 0;
+            const dAlign = front ? depth / 2 : back ? -depth / 2 : 0;
+            outer.position.set(disable || disableX ? 0 : -center.x + hAlign, disable || disableY ? 0 : -center.y + vAlign, disable || disableZ ? 0 : -center.z + dAlign);
+            // Only fire onCentered if the bounding box has changed
+            if (typeof onCentered !== 'undefined') {
+                onCentered({
+                    parent: this.node.parent,
+                    container: this.node,
+                    width,
+                    height,
+                    depth,
+                    boundingBox: box3,
+                    boundingSphere: sphere,
+                    center: center,
+                    verticalAlignment: vAlign,
+                    horizontalAlignment: hAlign,
+                    depthAlignment: dAlign
+                });
+            }
+        };
+    }
+}
+
 const vert_fullscreen = /*glsl*/ `
 varying vec2 vUv;
 void main() {
@@ -3984,6 +3657,143 @@ class ShadowMaterial extends ShaderMaterial {
     }
 }
 
+class Mount extends Component {
+    constructor(...args){
+        super(...args);
+        this.isMount = true;
+    }
+}
+
+class UI extends Mount {
+    get layerMask() {
+        return this._camera.layers.mask;
+    }
+    set layerMask(v) {
+        this._camera.layers.mask = v;
+    }
+    onLoad() {
+        const { width, height } = this.viewer;
+        const aspect = width / height;
+        this._camera = new OrthographicCamera(-aspect, aspect, 1, -1, -1000, 10000);
+        this._camera.layers.mask = 1 << 1;
+        this.viewer.on(DeviceInput.POINTER_DOWN, this._onPointerDown, this);
+        this.viewer.on(DeviceInput.POINTER_UP, this._onPointerUp, this);
+        this.viewer.on(DeviceInput.POINTER_MOVE, this._onPointerMove, this);
+        this.viewer.on(DeviceInput.MOUSE_WHEEL, this._onMouseWheel, this);
+        this.viewer.on(DeviceInput.TOUCH_START, this._onTouchStart, this);
+        this.viewer.on(DeviceInput.TOUCH_MOVE, this._onTouchMove, this);
+    }
+    onDestroy() {
+        this.viewer.targetOff(this);
+    }
+    _onPointerDown(e) {
+        if (SystemInfo.isMobile) return;
+        this._button = e.button;
+        this._preLoc0.set(e.pageX, e.pageY);
+    }
+    _onPointerUp(e) {
+        if (SystemInfo.isMobile) return;
+        this._button = -1;
+    }
+    _onPointerMove(e) {
+        if (SystemInfo.isMobile) return;
+        const { __loc0, __panOffset } = UI;
+        __loc0.set(e.pageX, e.pageY);
+        switch(this._button){
+            case 0:
+                this._setTargetPosition(this._calculatePanDelta(__panOffset, __loc0, this._preLoc0));
+                break;
+        }
+        this._preLoc0.copy(__loc0);
+    }
+    _onMouseWheel(e) {
+        if (e.deltaY > 0) {
+            this._targetZoom *= 0.85;
+        } else if (e.deltaY < 0) {
+            this._targetZoom /= 0.85;
+        }
+    }
+    _onTouchStart(e) {
+        if (!SystemInfo.isMobile) return;
+        let touches = e.touches;
+        if (touches.length > 1) {
+            this._preLoc0.set(touches[0].pageX, touches[0].pageY);
+            this._preLoc1.set(touches[1].pageX, touches[1].pageY);
+        } else if (touches.length > 0) {
+            this._touchID = touches[0].identifier;
+            this._preLoc0.set(touches[0].pageX, touches[0].pageY);
+        }
+    }
+    _onTouchMove(e) {
+        if (!SystemInfo.isMobile) return;
+        const { __loc0, __loc1, __panOffset } = UI;
+        let touches = e.touches;
+        if (touches.length > 1) {
+            __loc0.set(touches[0].pageX, touches[0].pageY);
+            __loc1.set(touches[1].pageX, touches[1].pageY);
+            this._targetZoom /= this._preLoc0.distanceTo(this._preLoc1) / __loc0.distanceTo(__loc1);
+            this._preLoc0.copy(__loc0);
+            this._preLoc1.copy(__loc1);
+        } else if (touches.length > 0) {
+            if (this._touchID === touches[0].identifier) {
+                __loc0.set(touches[0].pageX, touches[0].pageY);
+                this._setTargetPosition(this._calculatePanDelta(__panOffset, __loc0, this._preLoc0));
+                this._preLoc0.copy(__loc0);
+            }
+        }
+    }
+    _setTargetPosition(panOffset) {
+        this._targetPosition.x -= panOffset.x;
+        this._targetPosition.y += panOffset.y;
+    }
+    _calculatePanDelta(out, loc0, loc1) {
+        out.copy(loc0).sub(loc1);
+        out.x *= (this._camera.right - this._camera.left) / this._camera.zoom / this.viewer.width;
+        out.y *= (this._camera.top - this._camera.bottom) / this._camera.zoom / this.viewer.height;
+        return out;
+    }
+    update(dt) {
+        this._camera.position.x = FInterpTo(this._camera.position.x, this._targetPosition.x, dt, 5, 0.001);
+        this._camera.position.y = FInterpTo(this._camera.position.y, this._targetPosition.y, dt, 5, 0.001);
+        this._zoom = FInterpTo(this._zoom, this._targetZoom, dt, 5, 0.001);
+        if (this._zoom !== this._targetZoom) {
+            this._camera.zoom = this._zoom;
+            this._camera.updateProjectionMatrix();
+        }
+    }
+    resize(width, height) {
+        const aspect = width / height;
+        this._camera.left = -aspect;
+        this._camera.right = aspect;
+        this._camera.top = 1;
+        this._camera.bottom = -1;
+        this._camera.updateProjectionMatrix();
+    }
+    render(dt) {
+        const { renderer, scene } = this.viewer;
+        const autoClearDepth = renderer.autoClearDepth;
+        const autoClearColor = renderer.autoClearColor;
+        renderer.autoClearDepth = true;
+        renderer.autoClearColor = false;
+        renderer.render(scene, this._camera);
+        renderer.autoClearDepth = autoClearDepth;
+        renderer.autoClearColor = autoClearColor;
+    }
+    constructor(...args){
+        super(...args);
+        this._zoom = 1;
+        this._targetZoom = 0.3;
+        this._targetPosition = new Vector2();
+        this._button = -1;
+        this._touchID = -1;
+        this._preLoc0 = new Vector2();
+        this._preLoc1 = new Vector2();
+    }
+}
+UI.__loc0 = new Vector2();
+UI.__loc1 = new Vector2();
+UI.__panOffset = new Vector2();
+
 const LOD_MIN = 4;
 const _flatCamera = /*@__PURE__*/ new OrthographicCamera();
 // Golden Ratio
@@ -4541,7 +4351,7 @@ class ComponentManager {
         this._componentsMap.forEach((v)=>v.forEach(callback));
     }
     _addDendencies(node, constructor) {
-        while(constructor !== Component){
+        while(constructor && constructor !== Component){
             let info = ComponentManager._infoMap.get(constructor);
             if (info) {
                 const { components, mode } = info;
@@ -4721,6 +4531,7 @@ class ResourceManager {
         for (let ext of loader.extension){
             this._loaders.set(ext, loader);
         }
+        return loader;
     }
     loadAsset({ url, buffer, ext, path, resourcePath, dracoPath, manager, onProgress, ...props }) {
         return new Promise((resolve, reject)=>{
@@ -4766,6 +4577,9 @@ ResourceManager._texSettingKeys = [
     "channel"
 ];
 
+Object3D.prototype.apply = function(props) {
+    return applyProps(this, props);
+};
 class Viewer extends EventEmitter {
     static _setDirectLightShadow(shadow, props) {
         const shadowCamera = shadow.camera;
@@ -4898,15 +4712,14 @@ class Viewer extends EventEmitter {
         this._taskManager.destroy();
         this._resourceManager.destroy();
         this._componentManager.destroy();
-        this._tweens.forEach((tween)=>tween.killAll());
-        this._tweens = [];
         this._input.removeAllListeners();
     }
     _addDefaultLoaders() {
-        this.addLoader(aGLTFLoader);
-        this.addLoader(aHDRLoader);
-        this.addLoader(aTextureLoader);
-        this.addLoader(aJSONLoader);
+        this.addLoader(GLTFLoader);
+        this.addLoader(HDRLoader);
+        this.addLoader(TextureLoader);
+        this.addLoader(JSONLoader);
+        this.addLoader(BINLoader);
     }
     _frame(time) {
         this._time = time;
@@ -4929,7 +4742,6 @@ class Viewer extends EventEmitter {
         this.render(dt);
     }
     update(dt) {
-        this._tweens.forEach((tween)=>tween.update(dt));
         this._taskManager.update();
         this._componentManager.update(dt);
     }
@@ -5035,7 +4847,7 @@ class Viewer extends EventEmitter {
         return this._resourceManager.getLoader(ext);
     }
     addLoader(Loader) {
-        this._resourceManager.addLoader(Loader);
+        return this._resourceManager.addLoader(Loader);
     }
     traverseMaterials(callback) {
         this._scene.traverse((item)=>{
@@ -5051,15 +4863,10 @@ class Viewer extends EventEmitter {
     mount(constructor, autoAdd = false) {
         return this._componentManager.getComponent(this._mount, constructor, autoAdd);
     }
-    tween() {
-        const tween = new TweenManager();
-        this._tweens.push(tween);
-        return tween;
-    }
     task(task) {
         this._taskManager.add(task);
     }
-    add(object, { node, args, debug, scale, position, rotation, layer, shadowArgs, makeDefault, component, parent = this._scene, ...props } = {}) {
+    add(object, { node, args, debug, scale, position, rotation, shadowArgs, makeDefault, component, layer, parent = this._scene, ...props } = {}) {
         let ins = getClassInstance(object, args);
         if (ins.isObject3D) {
             node = ins;
@@ -5218,7 +5025,6 @@ class Viewer extends EventEmitter {
         this._targetFrameRate = -1;
         this._fixedFrameTime = false;
         this._autoResize = true;
-        this._tweens = [];
         const el = canvas || document.getElementById("canvas");
         const webgl = parepareWebGL(el, webglOpts);
         if (!webgl) {
@@ -5498,13 +5304,6 @@ class MergeMipBlurPass {
     }
 }
 
-class Mount extends Component {
-    constructor(...args){
-        super(...args);
-        this.isMount = true;
-    }
-}
-
 class Environment extends Mount {
     get envMap() {
         return this._reflectPass.envMap;
@@ -5827,6 +5626,7 @@ class DropFile extends Mount {
         }
     }
     _loadFile(file, dir = "") {
+        const viewer = this.viewer;
         const filename = file.name;
         const ext = ResourceManager.extension(filename);
         if (this._extensions.some((v)=>v === ext)) {
@@ -5849,7 +5649,11 @@ class DropFile extends Mount {
                 "glb"
             ].some((v)=>v === ext)) {
                 reader.addEventListener("load", (event)=>{
-                    this.viewer.loadAsset({
+                    if (this._raw) loadCallback({
+                        userData: {},
+                        raw: event.target.result
+                    });
+                    else viewer.loadAsset({
                         ext,
                         buffer: event.target.result,
                         resourcePath: dir
@@ -5858,7 +5662,11 @@ class DropFile extends Mount {
                 reader.readAsArrayBuffer(file);
             } else {
                 reader.addEventListener("load", (event)=>{
-                    this.viewer.loadAsset({
+                    if (this._raw) loadCallback({
+                        userData: {},
+                        raw: event.target.result
+                    });
+                    else viewer.loadAsset({
                         ext,
                         url: event.target.result
                     }).then(loadCallback).catch(errCallback);
@@ -5872,8 +5680,9 @@ class DropFile extends Mount {
         "gltf",
         "fbx",
         "hdr"
-    ] } = {}){
+    ], raw = false } = {}){
         super();
+        this._raw = false;
         this._onDrogOver = (e)=>{
             e.preventDefault();
             e.dataTransfer.dropEffect = "copy";
@@ -5892,6 +5701,7 @@ class DropFile extends Mount {
         this._extensions = Array.isArray(extension) ? extension : [
             extension
         ];
+        this._raw = raw;
     }
 }
 function createFilesMap(files) {
@@ -5941,5 +5751,5 @@ function getFilesFromItemList(items, onDone) {
     }
 }
 
-export { Animation, AnimationCurve, Box, BoxProjection, CinestationBlendDefinition, CinestationBrain, Component, ContactShadows, DependentMode, DeviceInput, DropFile, Easing, Environment, EventEmitter, FInterpConstantTo, FInterpTo, FreelookVirtualCamera, Logger, Mount, ObjectInstance, Orientation, PerformanceMonitor, Perlin, Plane, PropertyManager, QInterpConstantTo, QInterpTo, Quat_AngularDistance, Quat_Equals, Quat_exponentialDamp, Quat_quarticDamp, Quat_smoothDamp, Reflector, ReflectorMaterial, ResourceManager, ShadowMaterial, Sphere, SystemInfo, Tween, TweenChain, TweenGroup, TweenManager, VInterpConstantTo, VInterpTo, Vec3_smoothDamp, Vector3_NEG_ONE, Vector3_ONE, Vector3_RIGHT, Vector3_UNIT_X, Vector3_UNIT_Y, Vector3_UNIT_Z, Vector3_UP, Vector3_ZERO, Viewer, VirtualCamera, aEXRLoader, aFBXLoader, aGLTFLoader, aHDRLoader, aJSONLoader, aLoader, aTextureLoader, applyProps, dependencies, exponentialDamp, find, frag_BoxfilterBlur, frag_cubeMapToPanorama, frag_panoramaToCubeMap, getChildByName, getChildren, getClassInstance, getShaderMaterial, mixin, property, quarticDamp, queryValues, smoothDamp, vert_fullscreen };
+export { AccumulativeShadows, Animation, AnimationCurve, BINLoader, Box, BoxProjection, Center, CinestationBlendDefinition, CinestationBrain, Component, ContactShadows, DependentMode, DeviceInput, DropFile, EXRLoader, Easing, Environment, EventEmitter, FBXLoader, FInterpConstantTo, FInterpTo, FreelookVirtualCamera, GLTFLoader, HDRLoader, JSONLoader, Loader, Logger, Mount, ObjectInstance, Orientation, PerformanceMonitor, Perlin, Plane, PropertyManager, QInterpConstantTo, QInterpTo, Quat_AngularDistance, Quat_Equals, Quat_exponentialDamp, Quat_quarticDamp, Quat_smoothDamp, RandomizedLight, Reflector, ReflectorMaterial, ResourceManager, ShadowMaterial, Sphere, SystemInfo, TextureLoader, UI, VInterpConstantTo, VInterpTo, Vec3_smoothDamp, Vector3_NEG_ONE, Vector3_ONE, Vector3_RIGHT, Vector3_UNIT_X, Vector3_UNIT_Y, Vector3_UNIT_Z, Vector3_UP, Vector3_ZERO, Viewer, VirtualCamera, applyProps, dependencies, exponentialDamp, find, frag_BoxfilterBlur, frag_cubeMapToPanorama, frag_panoramaToCubeMap, getChildByName, getChildren, getClassInstance, getShaderMaterial, mixin, property, quarticDamp, queryValues, smoothDamp, vert_fullscreen };
 //# sourceMappingURL=module.js.map