@xviewer.js/core 1.0.5-alhpa.8 → 1.0.5

package/dist/main.cjs

@@ -3,13 +3,14 @@
 var EXRLoader_js = require('three/examples/jsm/loaders/EXRLoader.js');
 var FBXLoader_js = require('three/examples/jsm/loaders/FBXLoader.js');
 var GLTFLoader_js = require('three/examples/jsm/loaders/GLTFLoader.js');
-var DRACOLoader_js = require('three/examples/jsm/loaders/DRACOLoader.js');
 var meshopt_decoder_module_js = require('three/examples/jsm/libs/meshopt_decoder.module.js');
-var THREE = require('three');
 var HDRLoader_js = require('three/examples/jsm/loaders/HDRLoader.js');
+var THREE = require('three');
 var SVGLoader_js = require('three/examples/jsm/loaders/SVGLoader.js');
-var KTX2Loader_js = require('three/examples/jsm/loaders/KTX2Loader.js');
 var Addons_js = require('three/examples/jsm/Addons.js');
+var DRACOLoader_js = require('three/examples/jsm/loaders/DRACOLoader.js');
+var KTX2Loader_js = require('three/examples/jsm/loaders/KTX2Loader.js');
+var STLLoader_js = require('three/examples/jsm/loaders/STLLoader.js');
 
 function _interopNamespaceDefault(e) {
     var n = Object.create(null);
@@ -164,65 +165,18 @@ function getClassInstance(constructor, args = []) {
 }
 
 class Loader {
-    static _setUserData(node) {
-        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)=>{
-            Loader._texKeys.forEach((k)=>{
-                let tex = mat[k];
-                if (tex) {
-                    textures[tex.uuid] = tex;
-                }
-            });
-        });
-        Object.assign(node.userData, {
-            meshes,
-            textures: Object.values(textures),
-            materials: Object.values(materials)
-        });
-        return node;
-    }
-    constructor(viewer){
-        this.viewer = viewer;
-    }
-}
-Loader._texKeys = [
-    "map",
-    "alphaMap",
-    "aoMap",
-    "bumpMap",
-    "displacementMap",
-    "emissiveMap",
-    "envMap",
-    "lightMap",
-    "metalnessMap",
-    "normalMap",
-    "roughnessMap",
-    "specularMap",
-    "alphaMap"
-];
+    constructor(manager){
+        this.manager = manager;
+    }
+}
 
 class EXRLoader extends Loader {
-    load({ url, path, resourcePath, manager, texSettings, onLoad, onProgress, onError }) {
+    load({ url, path, resourcePath, texSettings, onLoad, onProgress, onError }) {
         let loader = this._loader;
         if (loader === undefined) {
             loader = this._loader = new EXRLoader_js.EXRLoader();
+            loader.manager = this.manager.loadingManager;
         }
-        loader.manager = manager;
         loader.setPath(path);
         loader.setResourcePath(resourcePath);
         loader.load(url, (tex)=>onLoad(Object.assign(tex, texSettings)), onProgress, onError);
@@ -235,12 +189,12 @@ class EXRLoader extends Loader {
 }
 
 class FBXLoader extends Loader {
-    load({ url, buffer, path, resourcePath, manager, onLoad, onProgress, onError }) {
+    load({ url, buffer, path, resourcePath, onLoad, onProgress, onError }) {
         let loader = this._loader;
         if (loader === undefined) {
             loader = this._loader = new FBXLoader_js.FBXLoader();
+            loader.manager = this.manager.loadingManager;
         }
-        loader.manager = manager;
         loader.setPath(path);
         loader.setResourcePath(resourcePath);
         if (buffer) {
@@ -257,20 +211,15 @@ class FBXLoader extends Loader {
 }
 
 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_js.DRACOLoader();
-        }
-        dracoLoader.manager = manager;
-        dracoLoader.setDecoderPath(dracoPath);
+    load({ url, buffer, path, resourcePath, onLoad, onProgress, onError }) {
         let loader = this._loader;
         if (loader === undefined) {
             loader = this._loader = new GLTFLoader_js.GLTFLoader();
-            loader.setDRACOLoader(dracoLoader);
+            loader.manager = this.manager.loadingManager;
             loader.setMeshoptDecoder(meshopt_decoder_module_js.MeshoptDecoder);
+            loader.setDRACOLoader(this.manager.dracoLoader);
+            loader.setKTX2Loader(this.manager.ktx2Loader);
         }
-        loader.manager = manager;
         loader.setPath(path);
         loader.setResourcePath(resourcePath);
         const cb = (gltf)=>{
@@ -306,19 +255,15 @@ class GLTFLoader extends Loader {
 }
 
 class HDRLoader extends Loader {
-    load({ url, path, resourcePath, manager, texSettings, onLoad, onProgress, onError }) {
+    load({ url, path, resourcePath, texSettings, onLoad, onProgress, onError }) {
         let loader = this._loader;
         if (loader === undefined) {
             loader = this._loader = new HDRLoader_js.HDRLoader();
+            loader.manager = this.manager.loadingManager;
         }
-        loader.manager = manager;
         loader.setPath(path);
         loader.setResourcePath(resourcePath);
-        const loadCallback = (tex)=>{
-            tex.mapping = THREE.EquirectangularReflectionMapping;
-            onLoad(Object.assign(tex, texSettings));
-        };
-        loader.load(url, loadCallback, onProgress, onError);
+        loader.load(url, (tex)=>onLoad(Object.assign(tex, texSettings)), onProgress, onError);
     }
     constructor(...args){
         super(...args), this.extension = [
@@ -328,12 +273,12 @@ class HDRLoader extends Loader {
 }
 
 class JSONLoader extends Loader {
-    load({ url, path, resourcePath, manager, onLoad, onProgress, onError }) {
+    load({ url, path, resourcePath, onLoad, onProgress, onError }) {
         let loader = this._loader;
         if (loader === undefined) {
             loader = this._loader = new THREE.FileLoader();
+            loader.manager = this.manager.loadingManager;
         }
-        loader.manager = manager;
         loader.setPath(path);
         loader.setResourcePath(resourcePath);
         loader.load(url, (file)=>onLoad(JSON.parse(file)), onProgress, onError);
@@ -346,12 +291,12 @@ class JSONLoader extends Loader {
 }
 
 class TextureLoader extends Loader {
-    load({ url, path, resourcePath, manager, texSettings, onLoad, onProgress, onError }) {
+    load({ url, path, resourcePath, texSettings, onLoad, onProgress, onError }) {
         let loader = this._loader;
         if (loader === undefined) {
             loader = this._loader = new THREE.TextureLoader();
+            loader.manager = this.manager.loadingManager;
         }
-        loader.manager = manager;
         loader.setPath(path);
         loader.setResourcePath(resourcePath);
         const loadCallback = (tex)=>{
@@ -370,86 +315,13 @@ class TextureLoader extends Loader {
     }
 }
 
-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_js.DRACOLoader();
-        }
-        dracoLoader.manager = manager;
-        dracoLoader.setDecoderPath(dracoPath);
-        let loader = this._loader;
-        if (loader === undefined) {
-            loader = this._loader = new CustomLoader();
-            loader.setDRACOLoader(dracoLoader);
-            loader.setMeshoptDecoder(meshopt_decoder_module_js.MeshoptDecoder);
-        }
-        loader.salt = this.salt;
-        loader.manager = manager;
-        loader.setPath(path);
-        loader.setResourcePath(resourcePath);
-        if (buffer) {
-            loader.parse(buffer, resourcePath, onLoad, onError);
-        } else {
-            loader.load(url, onLoad, onProgress, onError);
-        }
-    }
-    constructor(...args){
-        super(...args), this.extension = [
-            "bin"
-        ], this.salt = 255;
-    }
-}
-class CustomLoader extends GLTFLoader_js.GLTFLoader {
-    parse(data, path, onLoad, onError) {
-        super.parse(glbDecode(data, this.salt), path, onLoad, onError);
-    }
-    constructor(...args){
-        super(...args), this.salt = 255;
-    }
-}
-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;
-    }
-    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;
-}
-
 class SVGLoader extends Loader {
-    load({ url, path, resourcePath, manager, onLoad, onProgress, onError }) {
+    load({ url, path, resourcePath, onLoad, onProgress, onError }) {
         let loader = this._loader;
         if (loader === undefined) {
             loader = this._loader = new SVGLoader_js.SVGLoader();
+            loader.manager = this.manager.loadingManager;
         }
-        loader.manager = manager;
         loader.setPath(path);
         loader.setResourcePath(resourcePath);
         loader.load(url, onLoad, onProgress, onError);
@@ -463,21 +335,12 @@ class SVGLoader extends Loader {
 SVGLoader.Primitive = SVGLoader_js.SVGLoader;
 
 class KTX2Loader extends Loader {
-    load({ url, path, resourcePath, transcoderPath, manager, texSettings, onLoad, onProgress, onError }) {
-        let loader = this._loader;
-        if (loader === undefined) {
-            loader = this._loader = new KTX2Loader_js.KTX2Loader();
-            loader.setTranscoderPath(transcoderPath);
-            loader.detectSupport(this.viewer.renderer);
-        }
-        loader.manager = manager;
+    load({ url, path, resourcePath, texSettings, onLoad, onProgress, onError }) {
+        const loader = this.manager.ktx2Loader;
         loader.setPath(path);
         loader.setResourcePath(resourcePath);
-        const loadCallback = (tex)=>{
-            tex.mapping = THREE.CubeUVReflectionMapping;
-            onLoad(Object.assign(tex, texSettings));
-        };
-        loader.load(url, loadCallback, onProgress, onError);
+        loader.manager = this.manager.loadingManager;
+        loader.load(url, (tex)=>onLoad(Object.assign(tex, texSettings)), onProgress, onError);
     }
     constructor(...args){
         super(...args), this.extension = [
@@ -565,7 +428,7 @@ const Vector3_NEG_ONE = Object.freeze(new THREE.Vector3(-1, -1, -1));
 
 const { clamp: clamp$2 } = THREE.MathUtils;
 const { max, abs, acos } = Math;
-const EPSILON = 1.e-6;
+const EPSILON = 1.e-8;
 const __deltaMap = new Map();
 __deltaMap.set(THREE.Vector3, new THREE.Vector3());
 __deltaMap.set(THREE.Vector2, new THREE.Vector2());
@@ -1312,7 +1175,7 @@ class Component extends ObjectInstance {
     }
     _onPreDestroy() {
         this.unscheduleAll();
-        this.manager.removeComponent(this.node, this);
+        this.manager.remove(this.node, this);
         if (this._enabled) {
             this.manager.componentScheduler.enableComponent(this, false);
         }
@@ -1660,19 +1523,6 @@ function getChildren(node, filter, group = false) {
     }
     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() {
@@ -2350,6 +2200,12 @@ function single() {
     };
 }
 class ComponentManager {
+    get started() {
+        return this._started;
+    }
+    get manual() {
+        return this._manual;
+    }
     get viewer() {
         return this._viewer;
     }
@@ -2359,45 +2215,62 @@ class ComponentManager {
     get componentScheduler() {
         return this._componentScheduler;
     }
-    destroy() {
-        this._componentsMap.forEach((components)=>components.forEach((comp)=>comp.destroy()));
-        this._componentsMap.clear();
+    destroy(node) {
+        if (node) {
+            let components = this._componentsMap.get(node);
+            if (components) {
+                components.forEach((comp)=>comp.destroy());
+                this._componentsMap.delete(node);
+            }
+            for (let child of node.children){
+                this.destroy(child);
+            }
+        } else {
+            this._componentsMap.forEach((components)=>components.forEach((comp)=>comp.destroy()));
+            this._componentsMap.clear();
+        }
     }
     tick(dt) {
         this._componentScheduler.tick(dt);
     }
     update(dt) {
+        if (!this._started) return;
         this._scheduler.update(dt);
         this._componentScheduler.start();
         this._componentScheduler.update(dt);
         this._componentScheduler.lastUpdate(dt);
     }
     render(dt) {
+        if (!this._started) return;
         this._componentScheduler.render(dt);
     }
     resize(width, height) {
         this.componentScheduler.resize(width, height);
     }
-    destroyComponents(node) {
-        let components = this._componentsMap.get(node);
-        if (components) {
-            components.forEach((comp)=>comp.destroy());
-            this._componentsMap.delete(node);
-        }
-        for (let child of node.children){
-            this.destroyComponents(child);
-        }
+    start() {
+        this._started = true;
+        return this;
     }
-    activeComponents(node) {
+    pause() {
+        this._started = false;
+        return this;
+    }
+    resume() {
+        return this.start();
+    }
+    stop() {
+        return this.pause();
+    }
+    active(node) {
         let components = this._componentsMap.get(node);
         if (components) {
             components.forEach((comp)=>this._activeComponent(comp, node.visible));
         }
         for (let child of node.children){
-            this.activeComponents(child);
+            this.active(child);
         }
     }
-    addComponent(node, constructor) {
+    add(node, constructor) {
         let root = node instanceof Component ? node.node : node;
         let func = typeof constructor === "function";
         const proto = func ? constructor : constructor.constructor;
@@ -2427,26 +2300,26 @@ class ComponentManager {
             throw Error("Add multiple components");
         }
     }
-    removeComponent(node, component) {
+    remove(node, component) {
         let components = this._componentsMap.get(node);
         if (components) {
             components.splice(components.indexOf(component), 1);
         }
         return this;
     }
-    getComponent(node, constructor) {
+    get(node, constructor) {
         return this._findComponent(node, constructor);
     }
-    getComponentInChildren(node, constructor) {
+    getInChildren(node, constructor) {
         let comp = this._findComponent(node, constructor);
         if (comp) return comp;
         for (let child of node.children){
-            if (comp = this.getComponentInChildren(child, constructor)) {
+            if (comp = this.getInChildren(child, constructor)) {
                 return comp;
             }
         }
     }
-    getComponentsInChidren(node, constructor, out = []) {
+    getAllInChildren(node, constructor, out = []) {
         let components = this._componentsMap.get(node);
         if (components) {
             for(let i = components.length; i--;){
@@ -2454,11 +2327,11 @@ class ComponentManager {
             }
         }
         for (let child of node.children){
-            this.getComponentsInChidren(child, constructor, out);
+            this.getAllInChildren(child, constructor, out);
         }
         return out;
     }
-    traverseComponents(callback) {
+    traverse(callback) {
         this._componentsMap.forEach((v)=>v.forEach(callback));
     }
     _addDendencies(node, constructor) {
@@ -2467,9 +2340,9 @@ class ComponentManager {
             if (info) {
                 const { components = [], mode } = info;
                 for (const dep of components){
-                    if (!this.getComponent(node, dep)) {
+                    if (!this.get(node, dep)) {
                         if (mode === 1) {
-                            this.addComponent(node, dep);
+                            this.add(node, dep);
                         } else {
                             throw `Should add ${dep.name} before adding ${constructor.name}`;
                         }
@@ -2493,11 +2366,15 @@ class ComponentManager {
     _activeComponent(comp, active) {
         this._componentScheduler.enableComponent(comp, active);
     }
-    constructor(viewer){
+    constructor(viewer, { manual = false } = {}){
         this._scheduler = new Scheduler();
         this._componentScheduler = new ComponentScheduler();
         this._componentsMap = new Map();
+        this._started = false;
+        this._manual = false;
         this._viewer = viewer;
+        this._manual = manual;
+        this._started = !manual;
     }
 }
 ComponentManager._infoMap = new Map();
@@ -2942,15 +2819,15 @@ class DeviceInput extends Component {
         this.viewer.emit(DeviceInput.TOUCH_MOVE, ex);
     }
     _onKeyDown(e) {
-        this._keys[e.key] = true;
+        this._keys[e.code] = true;
         this.viewer.emit(DeviceInput.KEYDOWN, e);
     }
     _onKeyPress(e) {
-        this._keys[e.key] = true;
+        this._keys[e.code] = true;
         this.viewer.emit(DeviceInput.KEYPRESS, e);
     }
     _onKeyUp(e) {
-        this._keys[e.key] = false;
+        this._keys[e.code] = false;
         this.viewer.emit(DeviceInput.KEYUP, e);
     }
     constructor(option){
@@ -3366,15 +3243,15 @@ class FreelookVirtualCamera extends Component {
         return out;
     }
     _calculateLookAtOffset(panDelta, out = new THREE.Vector3()) {
-        const { xAxis, yAxis, posDelta } = FreelookVirtualCamera;
+        const { xAxis, yAxis } = FreelookVirtualCamera;
+        this.node.updateMatrix();
         xAxis.setFromMatrixColumn(this.node.matrix, 0);
         yAxis.setFromMatrixColumn(this.node.matrix, 1);
         if (this.forbitAll || this.forbitPanOffsetY) {
             yAxis.y = 0;
             yAxis.normalize();
         }
-        posDelta.copy(this.node.position).sub(this.lookAt);
-        const length = posDelta.length() * 2 * tan(degToRad(this.fov * 0.5));
+        const length = this._spherical.radius * 2 * tan(degToRad(this.fov * 0.5));
         return out.set(0, 0, 0).sub(xAxis.multiplyScalar(panDelta.x * length)).add(yAxis.multiplyScalar(panDelta.y * length));
     }
     _setTargetLookAt(panDelta) {
@@ -3515,7 +3392,6 @@ FreelookVirtualCamera.center = new THREE.Vector2();
 FreelookVirtualCamera.preCenter = new THREE.Vector2();
 FreelookVirtualCamera.panDelta = new THREE.Vector2();
 FreelookVirtualCamera.rotateDelta = new THREE.Vector2();
-FreelookVirtualCamera.posDelta = new THREE.Vector3();
 FreelookVirtualCamera.lookAtOffset = new THREE.Vector3();
 FreelookVirtualCamera.xAxis = new THREE.Vector3();
 FreelookVirtualCamera.yAxis = new THREE.Vector3();
@@ -4469,18 +4345,50 @@ function _getMipBlurMaterial(lodMax, width, height) {
     });
 }
 
+class Task {
+    constructor(excute, name){
+        this.instanceId = Task._instanceCount++;
+        this.name = "task" + this.instanceId;
+        this.excute = excute;
+        this.name = name || this.name;
+    }
+}
+Task._instanceCount = 0;
+
 class TaskManager {
     get isComplete() {
         return this._taskIndex >= this._tasks.length;
     }
+    get started() {
+        return this._started;
+    }
+    get manual() {
+        return this._manual;
+    }
     destroy() {
         this._tasks = [];
         this._taskIndex = 0;
     }
-    add(task) {
+    start() {
+        this._started = true;
+        return this;
+    }
+    pause() {
+        this._started = false;
+        return this;
+    }
+    resume() {
+        return this.start();
+    }
+    add(task, name) {
+        if (typeof task === "function") {
+            task = new Task(task, name);
+        }
         this._tasks.push(task);
+        return task;
     }
     update() {
+        if (!this._started) return;
         let task = this._tasks[this._taskIndex];
         if (task) {
             try {
@@ -4501,69 +4409,20 @@ class TaskManager {
             }
         }
     }
-    constructor(onComplete, onProgress, onError){
-        this.onComplete = onComplete;
-        this.onProgress = onProgress;
-        this.onError = onError;
+    constructor({ manual = false, onComplete, onProgress, onError } = {}){
         this._tasks = [];
         this._taskIndex = 0;
         this._onStartCalled = false;
+        this._started = false;
+        this._manual = false;
+        this._manual = manual;
+        this._started = !manual;
+        this.onComplete = onComplete;
+        this.onProgress = onProgress;
+        this.onError = onError;
     }
 }
 
-function checkWebGL(canvas, props) {
-    let isSupportedBrowser = (SystemInfo.isChrome || SystemInfo.isSafari || SystemInfo.isEdge || SystemInfo.isFirefox || SystemInfo.isOpera) && !SystemInfo.isIE;
-    if (!isSupportedBrowser) {
-        Logger.error("Unsupport platform");
-        return null;
-    }
-    if (!(canvas instanceof HTMLCanvasElement)) {
-        Logger.error("Canvas is null");
-        return null;
-    }
-    let webglOpts = Object.assign({
-        alpha: false,
-        depth: true,
-        stencil: true,
-        antialias: false,
-        premultipliedAlpha: true,
-        preserveDrawingBuffer: false,
-        powerPreference: "high-performance",
-        failIfMajorPerformanceCaveat: false
-    }, props);
-    if (window.WebGL2RenderingContext) {
-        try {
-            const gl = canvas.getContext("webgl2", webglOpts);
-            return {
-                gl,
-                RENDER_TARGET_FLOAT_TYPE: THREE.HalfFloatType,
-                DATA_FLOAT_TYPE: THREE.FloatType
-            };
-        } catch (err) {
-            Logger.error(err);
-            return null;
-        }
-    } else if (window.WebGLRenderingContext) {
-        const gl = canvas.getContext("webgl", webglOpts) || canvas.getContext("webgl2", webglOpts) || canvas.getContext("experimental-webgl", webglOpts);
-        if ((gl.getExtension("OES_texture_float") || gl.getExtension("OES_texture_half_float")) && gl.getParameter(gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS)) {
-            return {
-                gl,
-                RENDER_TARGET_FLOAT_TYPE: SystemInfo.isIOS || gl.getExtension("OES_texture_half_float") ? THREE.HalfFloatType : THREE.FloatType,
-                DATA_FLOAT_TYPE: THREE.FloatType
-            };
-        } else if (this._floatPacking) {
-            return {
-                gl,
-                RENDER_TARGET_FLOAT_TYPE: THREE.UnsignedByteType,
-                DATA_FLOAT_TYPE: THREE.UnsignedByteType
-            };
-        }
-        Logger.debug("Unspport float type in current platform");
-        return null;
-    }
-    return null;
-}
-
 var Orientation = /*#__PURE__*/ function(Orientation) {
     Orientation[Orientation["AUTO"] = 0] = "AUTO";
     Orientation[Orientation["LANDSCAPE"] = 1] = "LANDSCAPE";
@@ -4608,20 +4467,88 @@ class ResourceManager {
     get isComplete() {
         return this._loaded >= this._totalCount;
     }
+    get started() {
+        return this._started;
+    }
+    get manual() {
+        return this._manual;
+    }
+    get loadingManager() {
+        return this._loadingManager;
+    }
+    get ktx2Loader() {
+        return this._ktx2Loader;
+    }
+    get dracoLoader() {
+        return this._dracoLoader;
+    }
     destroy() {
         this._loaders.clear();
+        this._pendingAssets.length = 0;
+        this._readyWaiters.length = 0;
+    }
+    start() {
+        if (this._started) return this;
+        this._started = true;
+        this._flushPendingAssets();
+        return this;
+    }
+    pause() {
+        this._started = false;
+        return this;
+    }
+    ready() {
+        const total = this._totalCount;
+        if (this._loaded >= total) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve)=>{
+            this._readyWaiters.push({
+                total,
+                resolve
+            });
+        });
     }
     getLoader(ext) {
         return this._loaders.get(ext);
     }
     addLoader(Loader) {
-        let loader = new Loader(this._viewer);
+        let loader = new Loader(this);
         for (let ext of loader.extension){
             this._loaders.set(ext, loader);
         }
         return loader;
     }
-    loadAsset({ url, ext, onProgress, ...props }) {
+    load({ url, ext, onProgress, ...props }) {
+        return new Promise((resolve, reject)=>{
+            const fullUrl = url ? this._URL(url) : url;
+            const assetProps = Object.assign({
+                url: fullUrl,
+                ext,
+                onProgress
+            }, this._resourceOptions, props);
+            this._totalCount++;
+            if (this._started) {
+                this._load(assetProps).then(resolve).catch(reject);
+            } else {
+                this._pendingAssets.push({
+                    props: assetProps,
+                    resolve: resolve,
+                    reject
+                });
+            }
+        });
+    }
+    get(url) {
+        return this._resources.get(this._URL(url));
+    }
+    _flushPendingAssets() {
+        const assets = this._pendingAssets.splice(0);
+        for (const asset of assets){
+            this._load(asset.props).then(asset.resolve).catch(asset.reject);
+        }
+    }
+    _load({ url, ext, onProgress, ...props }) {
         return new Promise((resolve, reject)=>{
             const sel = ext || url && ResourceManager.extension(url) || "";
             const texSettings = ResourceManager._splitTextureSettings(props);
@@ -4634,28 +4561,56 @@ class ResourceManager {
                     onLoad: (asset)=>{
                         this._loaded++;
                         this._resources.set(url, asset);
+                        this._checkReadyWaiters();
                         resolve(asset);
                     },
                     onError: (err)=>{
+                        this._loaded++;
+                        this._checkReadyWaiters();
                         console.error(`${url} not exist`, err);
                         reject(err);
                     }
                 });
-                this._totalCount++;
             } else {
-                reject("ResourceManager.loadAsset: missing loader for " + sel);
+                this._loaded++;
+                this._checkReadyWaiters();
+                reject("ResourceManager.load: missing loader for " + sel);
             }
         });
     }
-    getAsset(url) {
-        return this._resources.get(url);
+    _checkReadyWaiters() {
+        for(let i = this._readyWaiters.length; i--;){
+            const waiter = this._readyWaiters[i];
+            if (this._loaded >= waiter.total) {
+                this._readyWaiters.splice(i, 1);
+                waiter.resolve();
+            }
+        }
     }
-    constructor(viewer){
+    constructor({ dracoPath, basisPath, loadingManager, renderer, path = "", resourcePath = "", URL = (url)=>url, manual = false }){
         this._loaders = new Map();
         this._resources = new Map();
+        this._pendingAssets = [];
+        this._readyWaiters = [];
         this._loaded = 0;
         this._totalCount = 0;
-        this._viewer = viewer;
+        this._started = false;
+        this._manual = false;
+        this._manual = manual;
+        this._started = !manual;
+        this._resourceOptions = {
+            path,
+            resourcePath
+        };
+        this._URL = URL;
+        this._loadingManager = loadingManager;
+        this._dracoLoader = new DRACOLoader_js.DRACOLoader();
+        this._dracoLoader.setDecoderPath(dracoPath);
+        this._dracoLoader.manager = loadingManager;
+        this._ktx2Loader = new KTX2Loader_js.KTX2Loader();
+        this._ktx2Loader.setTranscoderPath(basisPath);
+        this._ktx2Loader.detectSupport(renderer);
+        this._ktx2Loader.manager = loadingManager;
     }
 }
 ResourceManager._texSettingKeys = [
@@ -4673,15 +4628,27 @@ ResourceManager._texSettingKeys = [
     "channel"
 ];
 
-class Task {
-    constructor(excute, name){
-        this.instanceId = Task._instanceCount++;
-        this.name = "task" + this.instanceId;
-        this.excute = excute;
-        this.name = name || this.name;
+class STLLoader extends Loader {
+    load({ url, buffer, path, resourcePath, onLoad, onProgress, onError }) {
+        let loader = this._loader;
+        if (loader === undefined) {
+            loader = this._loader = new STLLoader_js.STLLoader();
+            loader.manager = this.manager.loadingManager;
+        }
+        loader.setPath(path);
+        loader.setResourcePath(resourcePath);
+        if (buffer) {
+            onLoad(loader.parse(buffer));
+        } else {
+            loader.load(url, onLoad, onProgress, onError);
+        }
+    }
+    constructor(...args){
+        super(...args), this.extension = [
+            "stl"
+        ];
     }
 }
-Task._instanceCount = 0;
 
 const vert_Fullscreen = `
 varying   vec2 v_uv;
@@ -4775,6 +4742,16 @@ void main() {
     gl_FragColor = color;
 }`;
 const EMPTY = {};
+const FRAME_TIME_EPSILON = 0.0005;
+const DefaultLoaders = [
+    STLLoader,
+    GLTFLoader,
+    HDRLoader,
+    TextureLoader,
+    JSONLoader,
+    SVGLoader,
+    KTX2Loader
+];
 class Viewer extends EventEmitter {
     get root() {
         return this._root;
@@ -4788,12 +4765,6 @@ class Viewer extends EventEmitter {
     get gl() {
         return this._gl;
     }
-    get RENDER_TARGET_FLOAT_TYPE() {
-        return this._RENDER_TARGET_FLOAT_TYPE;
-    }
-    get DATA_FLOAT_TYPE() {
-        return this._DATA_FLOAT_TYPE;
-    }
     get dpr() {
         return this._dpr;
     }
@@ -4812,17 +4783,31 @@ class Viewer extends EventEmitter {
     get input() {
         return this._input;
     }
+    get mount() {
+        return this._mount;
+    }
     get targetFrameRate() {
         return this._targetFrameRate;
     }
     set targetFrameRate(v) {
-        this._targetFrameRate = Math.max(0.001, v);
+        this._targetFrameRate = v < 0 ? -1 : Math.max(0.001, v);
+        this._lastTime = this._time;
+        this._lastFrameTime = this._time;
     }
     get instanceId() {
         return this._instanceId;
     }
-    get componentManager() {
-        return this._componentManager;
+    get loading() {
+        return this._loading;
+    }
+    get resources() {
+        return this._resources;
+    }
+    get tasks() {
+        return this._tasks;
+    }
+    get components() {
+        return this._components;
     }
     get scene() {
         return this._scene;
@@ -4842,23 +4827,21 @@ class Viewer extends EventEmitter {
     destroy() {
         this.stop();
         this._renderer.dispose();
-        this._taskManager.destroy();
-        this._resourceManager.destroy();
-        this._componentManager.destroy();
+        this._tasks.destroy();
+        this._resources.destroy();
+        this._components.destroy();
     }
     animate() {
         const loop = (dt)=>{
             if (!this._active) return;
-            this._componentManager.tick(dt);
-            if (this._resourceManager.isComplete) {
-                this._taskManager.update();
-            }
-            if (this._taskManager.isComplete) {
+            this._components.tick(dt);
+            this._tasks.update();
+            if (this._components.started) {
                 dt = Math.min(dt, 0.067);
-                this._componentManager.update(dt);
+                this._components.update(dt);
                 this._renderer.info.reset();
                 if (!this._freeze) {
-                    this._componentManager.render(dt);
+                    this._components.render(dt);
                 }
             }
         };
@@ -4867,10 +4850,10 @@ class Viewer extends EventEmitter {
             if (this._targetFrameRate > -1) {
                 const interval = 1 / this._targetFrameRate;
                 const delta = this._time - this._lastFrameTime;
-                if (delta >= interval) {
+                if (delta + FRAME_TIME_EPSILON >= interval) {
                     loop(this._fixedFrameTime ? interval : this._time - this._lastTime);
                     this._lastTime = this._time;
-                    this._lastFrameTime = this._time - delta % interval;
+                    this._lastFrameTime = delta >= interval ? this._time - delta % interval : this._lastFrameTime + interval;
                 }
             } else {
                 loop(this._time - this._lastTime);
@@ -4965,38 +4948,7 @@ class Viewer extends EventEmitter {
                 factor: width / w
             };
         }
-        this._componentManager.resize(width, height);
-    }
-    setURLModifier(callback) {
-        return this._loadingManager.setURLModifier(callback);
-    }
-    loadAsset({ url, ...props }) {
-        return this._resourceManager.loadAsset(Object.assign({
-            url: this._decodeURL(url)
-        }, this._resourceOptions, props));
-    }
-    getAsset(url) {
-        return this._resourceManager.getAsset(this._decodeURL(url));
-    }
-    getLoader(ext) {
-        return this._resourceManager.getLoader(ext);
-    }
-    addLoader(Loader) {
-        return this._resourceManager.addLoader(Loader);
-    }
-    getComponent(constructor, node) {
-        if (node) {
-            return this._componentManager.getComponent(node, constructor);
-        }
-        for (let child of this._mount.children){
-            let comp = this._componentManager.getComponent(child, constructor);
-            if (comp) return comp;
-        }
-    }
-    task(target) {
-        const excute = typeof target === "function" ? target : ()=>this.compile(target);
-        this._taskManager.add(new Task(excute));
-        return target;
+        this._components.resize(width, height);
     }
     use(object, props) {
         let ins = getClassInstance(object);
@@ -5031,7 +4983,7 @@ class Viewer extends EventEmitter {
                 node = new THREE.Object3D();
                 mount = true;
             }
-            this._componentManager.addComponent(node, ins);
+            this._components.add(node, ins);
         } else {
             throw Error("Unsuport object");
         }
@@ -5046,7 +4998,7 @@ class Viewer extends EventEmitter {
                 component
             ];
             for (const comp of components){
-                this._componentManager.addComponent(node, comp);
+                this._components.add(node, comp);
             }
         }
         if (children) {
@@ -5072,10 +5024,10 @@ class Viewer extends EventEmitter {
     }
     remove(ins) {
         if (ins instanceof THREE.Object3D) {
-            this._componentManager.destroyComponents(ins);
+            this._components.destroy(ins);
             ins.removeFromParent();
         } else if (ins instanceof Component) {
-            this._componentManager.removeComponent(ins.node, ins);
+            this._components.remove(ins.node, ins);
         } else {
             throw Error("remove invalid");
         }
@@ -5087,7 +5039,7 @@ class Viewer extends EventEmitter {
             wrapT: THREE.ClampToEdgeWrapping,
             magFilter: nearest ? THREE.NearestFilter : THREE.LinearFilter,
             minFilter: nearest ? THREE.NearestFilter : mipmap ? THREE.LinearMipMapLinearFilter : THREE.LinearFilter,
-            type: typeof floatType === "boolean" ? floatType ? this.DATA_FLOAT_TYPE : THREE.UnsignedByteType : floatType,
+            type: typeof floatType === "boolean" ? floatType ? THREE.HalfFloatType : THREE.UnsignedByteType : floatType,
             anisotropy: 0,
             colorSpace: THREE.LinearSRGBColorSpace,
             depthBuffer: depth,
@@ -5102,7 +5054,7 @@ class Viewer extends EventEmitter {
             wrapT: THREE.ClampToEdgeWrapping,
             magFilter: nearest ? THREE.NearestFilter : THREE.LinearFilter,
             minFilter: nearest ? THREE.NearestFilter : mipmap ? THREE.LinearMipMapLinearFilter : THREE.LinearFilter,
-            type: typeof floatType === "boolean" ? floatType ? this.DATA_FLOAT_TYPE : THREE.UnsignedByteType : floatType,
+            type: typeof floatType === "boolean" ? floatType ? THREE.HalfFloatType : THREE.UnsignedByteType : floatType,
             anisotropy: 0,
             colorSpace: THREE.LinearSRGBColorSpace,
             depthBuffer: depth,
@@ -5136,20 +5088,19 @@ class Viewer extends EventEmitter {
     }
     compile(target) {
         const { renderer, scene, camera } = this;
-        if (Array.isArray(target)) {
-            if (target.every((v)=>v.isMaterial)) {
-                Viewer.CompileMaterial(renderer, scene, camera, target);
-            } else {
-                throw Error("Viewer.compile: unsuport material");
+        const compile = (v)=>{
+            if (v.isMaterial) {
+                Viewer.CompileMaterial(renderer, scene, camera, v);
+            } else if (v.isObject3D) {
+                Viewer.CompileObject3D(renderer, scene, camera, v);
+            } else if (v.isTexture) {
+                Viewer.CompileTexture(renderer, v);
             }
+        };
+        if (Array.isArray(target)) {
+            target.forEach((v)=>compile(v));
         } else if (typeof target === "object") {
-            if (target.isMaterial) {
-                Viewer.CompileMaterial(renderer, scene, camera, target);
-            } else if (target.isObject3D) {
-                Viewer.CompileObject3D(renderer, scene, camera, target);
-            } else if (target.isTexture) {
-                Viewer.CompileTexture(renderer, target);
-            }
+            compile(target);
         } else {
             Viewer.CompileObject3D(renderer, scene, camera, scene);
         }
@@ -5259,7 +5210,7 @@ class Viewer extends EventEmitter {
         near: 0.1,
         far: 1000,
         position: new THREE.Vector3(0, 0, 4)
-    }, targetFrameRate = -1, fixedFrameTime = false, colorSpace = THREE.SRGBColorSpace, toneMapping = THREE.LinearToneMapping, toneMappingExposure = 1, maxDPR = 1.5, path = "", resourcePath = "", dracoPath = "https://www.gstatic.com/draco/v1/decoders/", transcoderPath = "three/examples/js/libs/basis/", orientation = Orientation.AUTO, decodeURL = (url)=>url, loader = {}, tasker = {}, ...webglOpts } = EMPTY){
+    }, targetFrameRate = -1, fixedFrameTime = false, colorSpace = THREE.SRGBColorSpace, toneMapping = THREE.LinearToneMapping, toneMappingExposure = 1, maxDPR = 1.5, path = "", resourcePath = "", dracoPath = "https://www.gstatic.com/draco/v1/decoders/", basisPath = "three/examples/js/libs/basis/", orientation = Orientation.AUTO, URL = (url)=>url, manual = false, resources = {}, tasks = {}, components = {}, ...webglOpts } = EMPTY){
         super(), this._instanceId = Viewer.instanceCount++, this._dpr = 1, this._width = 1, this._height = 1, this._viewport = {
             width: 1,
             height: 1,
@@ -5269,22 +5220,15 @@ class Viewer extends EventEmitter {
                 window.innerHeight
             ], this._orientation = Orientation.AUTO, this._freeze = false;
         const el = canvas || document.getElementById("canvas");
-        const webgl = checkWebGL(el, webglOpts);
-        if (!webgl) {
-            throw Error("Unsupport WebGL in current platform");
-        }
         this._canvas = el;
         this._root = root || el;
-        this._gl = webgl.gl;
-        this._RENDER_TARGET_FLOAT_TYPE = webgl.RENDER_TARGET_FLOAT_TYPE;
-        this._DATA_FLOAT_TYPE = webgl.DATA_FLOAT_TYPE;
         this._dpr = Math.min(maxDPR, window.devicePixelRatio);
         this._orientation = orientation;
         this._scene = new THREE.Scene();
         this._camera = applyProps(orthographic ? new THREE.OrthographicCamera() : new THREE.PerspectiveCamera(), camera);
         this._renderer = new THREE.WebGLRenderer({
             canvas: el,
-            context: webgl.gl
+            ...webglOpts
         });
         this._renderer.setPixelRatio(this._dpr);
         this._renderer.info.autoReset = false;
@@ -5294,37 +5238,50 @@ class Viewer extends EventEmitter {
         this._renderer.shadowMap.enabled = !!shadows;
         this._renderer.shadowMap.type = typeof shadows === "boolean" ? THREE.PCFSoftShadowMap : shadows;
         this._renderer.sortObjects = sortObjects;
+        this._gl = this._renderer.getContext();
         this._context = {
             scene: this._scene,
             camera: this._camera
         };
-        this._targetFrameRate = targetFrameRate;
+        this.targetFrameRate = targetFrameRate;
         this._windowSize = typeof resize === "function" ? resize : resize === ResizeMode.AUTO ? this._windowSize : null;
-        this._taskManager = new TaskManager(tasker.onComplete, tasker.onProgress, tasker.onError);
-        this._loadingManager = new THREE.LoadingManager(loader.onComplete, loader.onProgress, loader.onError);
-        this._resourceManager = new ResourceManager(this);
-        this._componentManager = new ComponentManager(this);
-        this._resourceOptions = {
+        var _resources_manual;
+        const resourcesManual = (_resources_manual = resources.manual) != null ? _resources_manual : manual;
+        var _tasks_manual;
+        const tasksManual = (_tasks_manual = tasks.manual) != null ? _tasks_manual : manual;
+        var _components_manual;
+        const componentsManual = (_components_manual = components.manual) != null ? _components_manual : manual;
+        this._tasks = new TaskManager({
+            manual: tasksManual,
+            onComplete: tasks.onComplete,
+            onProgress: tasks.onProgress,
+            onError: tasks.onError
+        });
+        this._loading = new THREE.LoadingManager(resources.onComplete, resources.onProgress, resources.onError);
+        this._resources = new ResourceManager({
+            manual: resourcesManual,
+            dracoPath,
+            basisPath,
+            renderer: this._renderer,
+            loadingManager: this._loading,
             path,
             resourcePath,
-            dracoPath,
-            transcoderPath,
-            manager: this._loadingManager
-        };
+            URL
+        });
+        var _resources_loaders;
+        for (const Loader of (_resources_loaders = resources.loaders) != null ? _resources_loaders : DefaultLoaders){
+            this._resources.addLoader(Loader);
+        }
+        this._components = new ComponentManager(this, {
+            manual: componentsManual
+        });
         this._mount = applyProps(new THREE.Object3D(), {
             name: "Mount"
         });
         this._input = this.add(new DeviceInput(input || {
             source: this._canvas
         }));
-        this._decodeURL = decodeURL;
         this.add(Renderer);
-        this.addLoader(GLTFLoader);
-        this.addLoader(HDRLoader);
-        this.addLoader(TextureLoader);
-        this.addLoader(JSONLoader);
-        this.addLoader(SVGLoader);
-        this.addLoader(KTX2Loader);
         this.rotate();
         this.resize();
         this.animate();
@@ -5887,6 +5844,7 @@ const defaultExtension = {
     "gltf": 0,
     "glb": 0,
     "buf": 0,
+    "exr": 2,
     "hdr": 2,
     "png": 2,
     "jpg": 2,
@@ -5910,7 +5868,7 @@ class DropFile extends Component {
         if (files.length > 0) {
             filesMap = filesMap || createFilesMap(files);
             dirs = dirs || [];
-            this.viewer.setURLModifier((url)=>{
+            this.viewer.loading.setURLModifier((url)=>{
                 url = url.replace(/^(\.?\/)/, ''); // remove './'
                 const file = filesMap[url];
                 if (file) {
@@ -5941,12 +5899,12 @@ class DropFile extends Component {
             this._onError && this._onError(err);
         };
         const viewer = this.viewer;
-        const loadAsset = (props)=>{
-            return viewer.loadAsset(props).then(loadCallback).catch(errCallback);
+        const load = (props)=>{
+            return viewer.resources.load(props).then(loadCallback).catch(errCallback);
         };
         switch(this._extension[ext]){
             case 2:
-                reader.addEventListener("load", (event)=>loadAsset({
+                reader.addEventListener("load", (event)=>load({
                         ext,
                         url: event.target.result
                     }), false);
@@ -5960,7 +5918,7 @@ class DropFile extends Component {
                 reader.readAsDataURL(file);
                 break;
             case 0:
-                reader.addEventListener("load", (event)=>loadAsset({
+                reader.addEventListener("load", (event)=>load({
                         ext,
                         buffer: event.target.result,
                         resourcePath: dir
@@ -5996,6 +5954,7 @@ class DropFile extends Component {
     }
 }
 DropFile.Mode = Mode;
+DropFile.defaultExtension = defaultExtension;
 DropFile = __decorate([
     single()
 ], DropFile);
@@ -6588,6 +6547,7 @@ uniform float u_opacity;
 uniform vec3  u_strokeColor;
 uniform float u_strokeWidth;
 uniform vec3  u_shadowColor;
+uniform float u_shadowOpacity;
 uniform float u_shadowBlur;
 uniform vec2  u_shadowOffset;
 uniform float u_weight;
@@ -6602,23 +6562,32 @@ float signedDistance(in vec2 uv) {
 }
 
 void main() {
-    vec4  color = vec4(u_color, 1.);
     float d = signedDistance(v_uv) + u_weight;
     float w = fwidth(d);
 
-    vec4 stroke = vec4(u_strokeColor, smoothstep(-w, w, d));
-    color.a *= smoothstep(-w, w, d - u_strokeWidth);
-    color = mix(stroke, color, color.a);
+    float outer = smoothstep(-w, w, d);
+    float inner = smoothstep(-w, w, d - u_strokeWidth);
+
+    float stroke = step(0.0001, u_strokeWidth);
+
+    vec4 color = vec4(u_color, inner);
+    color = mix(color, vec4(u_strokeColor, outer), stroke * (1.0 - inner));
 
     float sd = signedDistance(v_uv + u_shadowOffset) + u_weight;
-    vec4  shadow = vec4(u_shadowColor, smoothstep(-w - u_shadowBlur, w + u_shadowBlur, sd));
+    float sw = fwidth(sd) + u_shadowBlur;
+
+    vec4 shadow = vec4(
+        u_shadowColor,
+        smoothstep(-sw, sw, sd) * u_shadowOpacity
+    );
+
     color = mix(shadow, color, color.a);
 
     color.a *= u_opacity;
     gl_FragColor = color;
 
     #include <tonemapping_fragment>
-	#include <colorspace_fragment>
+    #include <colorspace_fragment>
 }
 `;
 class BMFontAtlas {
@@ -6706,13 +6675,16 @@ class BMFontAtlas {
                 value: 0
             },
             u_shadowColor: {
-                value: new THREE.Color(0xffffff)
+                value: new THREE.Color(0x606060)
+            },
+            u_shadowOpacity: {
+                value: 0
             },
             u_shadowBlur: {
                 value: 0
             },
             u_shadowOffset: {
-                value: new THREE.Vector2()
+                value: new THREE.Vector2(0.01, 0)
             },
             u_fontTexture: {
                 value: null
@@ -6737,7 +6709,6 @@ class BMFontAtlas {
 exports.AccumulativeShadows = AccumulativeShadows;
 exports.Animation = Animation;
 exports.AnimationCurve = AnimationCurve;
-exports.BINLoader = BINLoader;
 exports.BMFontAtlas = BMFontAtlas;
 exports.BMFontTextGeometry = BMFontTextGeometry;
 exports.BMFontTextLayout = BMFontTextLayout;
@@ -6745,7 +6716,9 @@ exports.Box = Box;
 exports.BoxProjection = BoxProjection;
 exports.Center = Center;
 exports.Component = Component;
+exports.ComponentManager = ComponentManager;
 exports.ContactShadows = ContactShadows;
+exports.DefaultLoaders = DefaultLoaders;
 exports.DependentMode = DependentMode;
 exports.DeviceInput = DeviceInput;
 exports.DropFile = DropFile;
@@ -6789,6 +6762,7 @@ exports.ShadowMaterial = ShadowMaterial;
 exports.Sphere = Sphere;
 exports.SystemInfo = SystemInfo;
 exports.Task = Task;
+exports.TaskManager = TaskManager;
 exports.TextureLoader = TextureLoader;
 exports.VInterpConstantTo = VInterpConstantTo;
 exports.VInterpTo = VInterpTo;
@@ -6809,14 +6783,12 @@ exports.find = find;
 exports.frag_BoxfilterBlur = frag_BoxfilterBlur;
 exports.frag_cubeMapToPanorama = frag_cubeMapToPanorama;
 exports.frag_panoramaToCubeMap = frag_panoramaToCubeMap;
-exports.getChildByName = getChildByName;
 exports.getChildren = getChildren;
 exports.getClassInstance = getClassInstance;
 exports.getShaderMaterial = getShaderMaterial;
 exports.mixin = mixin;
 exports.property = property;
 exports.quarticDamp = quarticDamp;
-exports.queryValues = queryValues;
 exports.single = single;
 exports.smoothDamp = smoothDamp;
 exports.vert_fullscreen = vert_fullscreen;