@xviewer.js/core 1.0.0-alpha.22 → 1.0.0-alpha.25

package/dist/main.js

@@ -1,11 +1,11 @@
 'use strict';
 
-var three = require('three');
 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 RGBELoader_js = require('three/examples/jsm/loaders/RGBELoader.js');
 
 class EventEmitter {
@@ -1008,34 +1008,41 @@ class TweenManager {
 
 class aLoader {
     static _setMeshData(node) {
-        const meshData = {
-            meshes: [],
-            materials: {},
-            textures: {}
-        };
-        const callback = (node)=>{
-            const materials = Array.isArray(node.material) ? node.material : [
-                node.material
-            ];
-            for (let mat of materials){
-                meshData.meshes.push(node);
-                meshData.materials[mat.name] = mat;
-                let tex = null;
-                for (let v of aLoader._materialMapKeys){
-                    tex = mat[v];
-                    tex && (meshData.textures[tex.uuid] = tex);
-                }
+        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.name] = v);
+                else materials[mat.name] = mat;
+                keys.forEach((k)=>{
+                    let tex = mat[k];
+                    if (tex) {
+                        textures[tex.uuid] = tex;
+                    }
+                });
             }
+            object.children.forEach((v)=>queue.push(v));
+        }
+        node.userData.meshData = {
+            meshes,
+            materials,
+            textures
         };
-        node.traverse((v)=>v instanceof three.Mesh && callback(v));
-        node.userData.meshData = meshData;
         return node;
     }
     constructor(manager){
         this.manager = manager;
     }
 }
-aLoader._materialMapKeys = [
+aLoader._texKeys = [
     "alphaMap",
     "aoMap",
     "bumpMap",
@@ -2891,6 +2898,706 @@ class Plane extends three.Mesh {
     }
 }
 
+const ReflectorShader = {
+    name: 'ReflectorShader',
+    uniforms: {
+        color: {
+            value: null
+        },
+        tDiffuse: {
+            value: null
+        },
+        textureMatrix: {
+            value: null
+        }
+    },
+    vertexShader: /* glsl */ `
+		uniform mat4 textureMatrix;
+		varying vec4 vUv;
+
+		#include <common>
+		#include <logdepthbuf_pars_vertex>
+
+		void main() {
+			vUv = textureMatrix * vec4( position, 1.0 );
+			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+			#include <logdepthbuf_vertex>
+		}`,
+    fragmentShader: /* glsl */ `
+		uniform vec3 color;
+		uniform sampler2D tDiffuse;
+		varying vec4 vUv;
+
+		#include <logdepthbuf_pars_fragment>
+
+		float blendOverlay( float base, float blend ) {
+			return( base < 0.5 ? ( 2.0 * base * blend ) : ( 1.0 - 2.0 * ( 1.0 - base ) * ( 1.0 - blend ) ) );
+		}
+
+		vec3 blendOverlay( vec3 base, vec3 blend ) {
+			return vec3( blendOverlay( base.r, blend.r ), blendOverlay( base.g, blend.g ), blendOverlay( base.b, blend.b ) );
+		}
+
+		void main() {
+			#include <logdepthbuf_fragment>
+
+			vec4 base = texture2DProj( tDiffuse, vUv );
+			gl_FragColor = vec4( blendOverlay( base.rgb, color ), 1.0 );
+
+			#include <tonemapping_fragment>
+			#include <colorspace_fragment>
+		}`
+};
+class Reflector extends three.Mesh {
+    constructor(options = {}){
+        super(options.geometry || new three.PlaneGeometry());
+        this.isReflector = true;
+        const color = options.color !== undefined ? new three.Color(options.color) : new three.Color(0x7F7F7F);
+        const textureWidth = options.textureWidth || 512;
+        const textureHeight = options.textureHeight || 512;
+        const clipBias = options.clipBias || 0;
+        const multisample = options.multisample !== undefined ? options.multisample : 4;
+        const defaultNormal = options.normal || new three.Vector3(0, 0, 1);
+        const reflectorPlane = new three.Plane();
+        const normal = new three.Vector3();
+        const reflectorWorldPosition = new three.Vector3();
+        const cameraWorldPosition = new three.Vector3();
+        const rotationMatrix = new three.Matrix4();
+        const lookAtPosition = new three.Vector3(0, 0, -1);
+        const clipPlane = new three.Vector4();
+        const view = new three.Vector3();
+        const target = new three.Vector3();
+        const q = new three.Vector4();
+        const textureMatrix = new three.Matrix4();
+        const virtualCamera = new three.PerspectiveCamera();
+        virtualCamera.layers.set(options.layer || 0);
+        const renderTarget = new three.WebGLRenderTarget(textureWidth, textureHeight, {
+            samples: multisample,
+            type: three.HalfFloatType
+        });
+        const shader = ReflectorShader;
+        const material = options.material || new three.ShaderMaterial({
+            name: shader.name ,
+            uniforms: three.UniformsUtils.clone(shader.uniforms),
+            fragmentShader: shader.fragmentShader,
+            vertexShader: shader.vertexShader
+        });
+        if (material.uniforms.tDiffuse) {
+            material.uniforms.tDiffuse.value = renderTarget.texture;
+        }
+        if (material.uniforms.textureMatrix) {
+            material.uniforms.textureMatrix.value = textureMatrix;
+        }
+        if (material.uniforms.color) {
+            material.uniforms.color.value = color;
+        }
+        this.material = material;
+        const scope = this;
+        this.onBeforeRender = function(renderer, scene, camera) {
+            reflectorWorldPosition.setFromMatrixPosition(scope.matrixWorld);
+            cameraWorldPosition.setFromMatrixPosition(camera.matrixWorld);
+            rotationMatrix.extractRotation(scope.matrixWorld);
+            normal.copy(defaultNormal);
+            normal.applyMatrix4(rotationMatrix);
+            view.subVectors(reflectorWorldPosition, cameraWorldPosition);
+            // Avoid rendering when reflector is facing away
+            if (view.dot(normal) > 0) return;
+            view.reflect(normal).negate();
+            view.add(reflectorWorldPosition);
+            rotationMatrix.extractRotation(camera.matrixWorld);
+            lookAtPosition.set(0, 0, -1);
+            lookAtPosition.applyMatrix4(rotationMatrix);
+            lookAtPosition.add(cameraWorldPosition);
+            target.subVectors(reflectorWorldPosition, lookAtPosition);
+            target.reflect(normal).negate();
+            target.add(reflectorWorldPosition);
+            virtualCamera.position.copy(view);
+            virtualCamera.up.set(0, 1, 0);
+            virtualCamera.up.applyMatrix4(rotationMatrix);
+            virtualCamera.up.reflect(normal);
+            virtualCamera.lookAt(target);
+            virtualCamera.far = camera.far; // Used in WebGLBackground
+            virtualCamera.updateMatrixWorld();
+            virtualCamera.projectionMatrix.copy(camera.projectionMatrix);
+            // Update the texture matrix
+            textureMatrix.set(0.5, 0.0, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0);
+            textureMatrix.multiply(virtualCamera.projectionMatrix);
+            textureMatrix.multiply(virtualCamera.matrixWorldInverse);
+            textureMatrix.multiply(scope.matrixWorld);
+            // Now update projection matrix with new clip plane, implementing code from: http://www.terathon.com/code/oblique.html
+            // Paper explaining this technique: http://www.terathon.com/lengyel/Lengyel-Oblique.pdf
+            reflectorPlane.setFromNormalAndCoplanarPoint(normal, reflectorWorldPosition);
+            reflectorPlane.applyMatrix4(virtualCamera.matrixWorldInverse);
+            clipPlane.set(reflectorPlane.normal.x, reflectorPlane.normal.y, reflectorPlane.normal.z, reflectorPlane.constant);
+            const projectionMatrix = virtualCamera.projectionMatrix;
+            q.x = (Math.sign(clipPlane.x) + projectionMatrix.elements[8]) / projectionMatrix.elements[0];
+            q.y = (Math.sign(clipPlane.y) + projectionMatrix.elements[9]) / projectionMatrix.elements[5];
+            q.z = -1.0;
+            q.w = (1.0 + projectionMatrix.elements[10]) / projectionMatrix.elements[14];
+            // Calculate the scaled plane vector
+            clipPlane.multiplyScalar(2.0 / clipPlane.dot(q));
+            // Replacing the third row of the projection matrix
+            projectionMatrix.elements[2] = clipPlane.x;
+            projectionMatrix.elements[6] = clipPlane.y;
+            projectionMatrix.elements[10] = clipPlane.z + 1.0 - clipBias;
+            projectionMatrix.elements[14] = clipPlane.w;
+            // Render
+            scope.visible = false;
+            const currentRenderTarget = renderer.getRenderTarget();
+            const currentActiveCubeFace = renderer.getActiveCubeFace();
+            const currentActiveMipmapLevel = renderer.getActiveMipmapLevel();
+            const currentXrEnabled = renderer.xr.enabled;
+            const currentShadowAutoUpdate = renderer.shadowMap.autoUpdate;
+            renderer.xr.enabled = false; // Avoid camera modification
+            renderer.shadowMap.autoUpdate = false; // Avoid re-computing shadows
+            renderer.setRenderTarget(renderTarget);
+            renderer.state.buffers.depth.setMask(true); // make sure the depth buffer is writable so it can be properly cleared, see #18897
+            if (renderer.autoClear === false) renderer.clear();
+            renderer.render(scene, virtualCamera);
+            renderer.xr.enabled = currentXrEnabled;
+            renderer.shadowMap.autoUpdate = currentShadowAutoUpdate;
+            renderer.setRenderTarget(currentRenderTarget, currentActiveCubeFace, currentActiveMipmapLevel);
+            // Restore viewport
+            const viewport = camera.viewport;
+            if (viewport !== undefined) {
+                renderer.state.viewport(viewport);
+            }
+            scope.visible = true;
+        };
+        this.getRenderTarget = function() {
+            return renderTarget;
+        };
+        this.getTextureMatrix = function() {
+            return textureMatrix;
+        };
+        this.dispose = function() {
+            renderTarget.dispose();
+            scope.material.dispose();
+        };
+    }
+}
+
+const vert_fullscreen = /*glsl*/ `
+varying vec2 vUv;
+void main() {
+	vUv = position.xy * 0.5 + 0.5;
+	gl_Position = vec4(position.xy, 1.0, 1.0);
+}
+`;
+
+const frag_BoxfilterBlur = `
+#include <common>
+uniform sampler2D tLast;
+uniform sampler2D tBlur;
+uniform float	  uLod;
+uniform float	  uWeight;
+varying vec2      vUv;
+
+void main() {
+	vec3 col0 = textureLod(tLast, vUv, 0.).rgb;
+	vec3 col1 = textureLod(tBlur, vUv, uLod).rgb;
+    gl_FragColor = vec4(mix(col0, col1, uWeight), 1.);
+}
+`;
+
+const frag_panoramaToCubeMap = `
+#include <xv_common>
+
+varying vec2      vUv;
+uniform sampler2D tMain;
+uniform int       uFace;
+uniform vec4      uTilingOffset;
+
+vec3 uvToXYZ(int face, vec2 uv) {
+    if (face == 0) return vec3(-1.0, uv.y, -uv.x);
+    else if (face == 1) return vec3(1.0, uv.y, uv.x);
+    else if (face == 2) return vec3(-uv.x, -1.0, uv.y);
+    else if (face == 3) return vec3(-uv.x, 1.0, -uv.y);
+    else if (face == 4) return vec3(-uv.x, uv.y, 1.0);
+    else return vec3(uv.x, uv.y, -1.0);
+}
+
+vec4 panoramaToCubeMap(int face, vec2 uv_i) {
+    vec2 uv = uv_i * 2.0 - 1.0;
+    vec3 dir = normalize(uvToXYZ(face, uv));
+    vec2 uv_o = dirToUv(dir);
+    uv_o = vec2(uv_o.x, uv_o.y) * uTilingOffset.xy + uTilingOffset.zw;
+    return texture(tMain, uv_o);
+}
+
+void main() {
+    gl_FragColor = panoramaToCubeMap(uFace, vUv);
+}
+`;
+const frag_cubeMapToPanorama = `
+#include <xv_common>
+
+varying vec2        vUv;
+uniform samplerCube tMain;
+
+vec4 cubeMapToPanorama(vec2 uv_i) {
+    return texture(tMain, uvToDir(uv_i));
+}
+
+void main() {
+    gl_FragColor = cubeMapToPanorama(vUv);
+}
+`;
+
+function getShaderMaterial(uniforms, vertexShader, fragmentShader, onInit) {
+    const material = class extends three.ShaderMaterial {
+        constructor(parameters = {}){
+            const entries = Object.entries(uniforms);
+            // Create unforms and shaders
+            super({
+                uniforms: entries.reduce((acc, [name, value])=>{
+                    const uniform = three.UniformsUtils.clone({
+                        [name]: {
+                            value
+                        }
+                    });
+                    return {
+                        ...acc,
+                        ...uniform
+                    };
+                }, {}),
+                vertexShader,
+                fragmentShader
+            });
+            // Create getter/setters
+            entries.forEach(([name])=>Object.defineProperty(this, name, {
+                    get: ()=>this.uniforms[name].value,
+                    set: (v)=>this.uniforms[name].value = v
+                }));
+            // Assign parameters, this might include uniforms
+            Object.assign(this, parameters);
+            // Call onInit
+            if (onInit) onInit(this);
+        }
+    };
+    return material;
+}
+
+const vert_Reflector = `
+uniform mat4 textureMatrix;
+varying vec4 vUv4;
+varying vec2 vUv;
+varying vec2 vUv1;
+varying vec3 vViewPosition;
+
+#include <common>
+#include <normal_pars_vertex>
+#include <logdepthbuf_pars_vertex>
+
+void main() {
+    #include <beginnormal_vertex>
+    #include <defaultnormal_vertex>
+
+    vec4 positionWS = modelMatrix * vec4(position, 1.0);
+    vec4 mvPosition = viewMatrix * positionWS;
+
+    vUv = uv;
+    vUv1 = uv1;
+    vUv4 = textureMatrix * vec4(position, 1.0);
+
+    vViewPosition = -mvPosition.xyz;
+    vNormal = normalize(transformedNormal);
+
+    gl_Position = projectionMatrix * mvPosition;
+    #include <logdepthbuf_vertex>
+}
+`;
+const frag_Reflector = `
+uniform vec3      color;
+uniform float     roughness;
+uniform float     metalness;
+uniform sampler2D tDiffuse;
+uniform sampler2D normalMap;
+uniform sampler2D roughnessMap;
+uniform sampler2D aoMap;
+uniform float aoMapIntensity;
+uniform sampler2D lightMap;
+uniform float lightMapIntensity;
+
+varying vec4 vUv4;
+varying vec2 vUv;
+varying vec2 vUv1;
+varying vec3 vViewPosition;
+varying vec3 vNormal;
+
+#include <common>
+#include <lights_physical_pars_fragment>
+#include <logdepthbuf_pars_fragment>
+
+void main() {
+    #include <logdepthbuf_fragment>
+
+    vec4 uv4 = vUv4;
+    vec4 texelNormal = texture2D(normalMap, vUv);
+    vec3 normal = normalize(vec3(texelNormal.r * 2.0 - 1.0, texelNormal.b,  texelNormal.g * 2.0 - 1.0));
+    vec3 coord = uv4.xyz / uv4.w;
+    vec2 reflectUv = coord.xy + coord.z * normal.xz * 0.05;
+
+    vec3 geometryNormal = normalize(vNormal);
+    vec3 geometryViewDir = normalize(vViewPosition);
+
+    vec3 singleScattering = vec3( 0.0 );
+	vec3 multiScattering = vec3( 0.0 );
+
+    float metalnessFactor = metalness;
+    vec3  diffuseColor = color.rgb * ( 1.0 - metalnessFactor );
+    vec3  specularColor = mix( vec3( 0.04 ), diffuseColor.rgb, metalnessFactor );
+    float specularF90 = 1.0;
+
+    float roughnessFactor = texture2D(roughnessMap, vUv).g * roughness;
+
+    computeMultiscattering( geometryNormal, geometryViewDir, specularColor, specularF90, roughnessFactor, singleScattering, multiScattering );
+
+    vec3 totalScattering = singleScattering + multiScattering;
+	vec3 diffuse = diffuseColor * ( 1.0 - max( max( totalScattering.r, totalScattering.g ), totalScattering.b ) );
+
+    vec3 irradiance = vec3(0.);
+    irradiance += texture2D(lightMap, vUv).rgb * lightMapIntensity;
+
+    float lod = roughnessFactor * (1.7 - 0.7 * roughnessFactor) * 6.;
+    vec4  reflectColor = textureLod(tDiffuse, reflectUv, lod);
+
+    vec3 f_specular = vec3(0.);
+    vec3 f_diffuse = vec3(0.);
+
+    f_specular += reflectColor.rgb * (1.0 - roughnessFactor * roughnessFactor) + multiScattering * irradiance;
+    f_diffuse += diffuse * irradiance;
+
+    float ambientOcclusion = mix(1., texture2D(aoMap, vUv1).r, aoMapIntensity);
+    float dotNV = saturate( dot( geometryNormal, geometryViewDir ) );
+    f_specular *= computeSpecularOcclusion(dotNV, ambientOcclusion, roughnessFactor);
+
+    gl_FragColor = vec4(f_specular + f_diffuse, 1.);
+
+    #include <tonemapping_fragment>
+    #include <colorspace_fragment>
+}
+`;
+class ReflectorMaterial extends three.ShaderMaterial {
+    get metalness() {
+        return this.uniforms.metalness.value;
+    }
+    set metalness(v) {
+        this.uniforms.metalness.value = v;
+    }
+    get roughness() {
+        return this.uniforms.roughness.value;
+    }
+    set roughness(v) {
+        this.uniforms.roughness.value = v;
+    }
+    get roughnessMap() {
+        return this.uniforms.roughnessMap.value;
+    }
+    set roughnessMap(v) {
+        this.uniforms.roughnessMap.value = v;
+    }
+    get normalMap() {
+        return this.uniforms.normalMap.value;
+    }
+    set normalMap(v) {
+        this.uniforms.normalMap.value = v;
+    }
+    get aoMap() {
+        return this.uniforms.aoMap.value;
+    }
+    set aoMap(v) {
+        this.uniforms.aoMap.value = v;
+    }
+    get lightMap() {
+        return this.uniforms.lightMap.value;
+    }
+    set lightMap(v) {
+        this.uniforms.lightMap.value = v;
+    }
+    constructor(...args){
+        super(...args);
+        this.vertexShader = vert_Reflector;
+        this.fragmentShader = frag_Reflector;
+        this.uniforms = {
+            color: {
+                value: new three.Color(0xffffff)
+            },
+            tDiffuse: {
+                value: null
+            },
+            textureMatrix: {
+                value: null
+            },
+            metalness: {
+                value: 0
+            },
+            roughness: {
+                value: 1
+            },
+            roughnessMap: {
+                value: null
+            },
+            normalMap: {
+                value: null
+            },
+            aoMap: {
+                value: null
+            },
+            aoMapIntensity: {
+                value: 1
+            },
+            lightMap: {
+                value: null
+            },
+            lightMapIntensity: {
+                value: 1
+            }
+        };
+    }
+}
+__decorate([
+    property({
+        min: 0,
+        max: 1,
+        step: 0.01
+    })
+], ReflectorMaterial.prototype, "metalness", null);
+__decorate([
+    property({
+        min: 0,
+        max: 1,
+        step: 0.01
+    })
+], ReflectorMaterial.prototype, "roughness", null);
+
+class Plugin extends ObjectInstance {
+    constructor(...args){
+        super(...args);
+        this.type = "Plugin";
+    }
+}
+
+class DebugPlugin extends Plugin {
+    static Instance(viewer) {
+        return viewer.getPlugin(DebugPlugin, true);
+    }
+    add(node) {
+        this.scene.add(node);
+        return node;
+    }
+    remove(node) {
+        this.scene.remove(node);
+        return node;
+    }
+    onRender(dt) {
+        const { renderer, camera } = this.viewer;
+        const autoClear = renderer.autoClear;
+        renderer.autoClear = false;
+        renderer.render(this.scene, camera);
+        renderer.autoClear = autoClear;
+    }
+    constructor(...args){
+        super(...args);
+        this.scene = new three.Scene();
+    }
+}
+
+const LOD_MIN = 4;
+const _flatCamera = /*@__PURE__*/ new three.OrthographicCamera();
+function _setViewport(target, x, y, width, height) {
+    target.viewport.set(x, y, width, height);
+    target.scissor.set(x, y, width, height);
+}
+function _getCommonVertexShader() {
+    return /* glsl */ `
+		precision mediump float;
+		precision mediump int;
+
+		attribute float faceIndex;
+
+		varying vec3 vOutputDirection;
+
+		// RH coordinate system; PMREM face-indexing convention
+		vec3 getDirection( vec2 uv, float face ) {
+
+			uv = 2.0 * uv - 1.0;
+			vec3 direction = vec3( uv, 1.0 );
+
+			if ( face == 0.0 ) {
+				direction = direction.zyx; // ( 1, v, u ) pos x
+			} else if ( face == 1.0 ) {
+				direction = direction.xzy;
+				direction.xz *= -1.0; // ( -u, 1, -v ) pos y
+			} else if ( face == 2.0 ) {
+				direction.x *= -1.0; // ( -u, v, 1 ) pos z
+			} else if ( face == 3.0 ) {
+				direction = direction.zyx;
+				direction.xz *= -1.0; // ( -1, v, -u ) neg x
+			} else if ( face == 4.0 ) {
+				direction = direction.xzy;
+				direction.xy *= -1.0; // ( -u, -1, v ) neg y
+			} else if ( face == 5.0 ) {
+				direction.z *= -1.0; // ( u, v, -1 ) neg z
+			}
+
+			return direction;
+
+		}
+
+		void main() {
+			vOutputDirection = getDirection( uv, faceIndex );
+			gl_Position = vec4( position, 1.0 );
+		}
+	`;
+}
+function _getClearMaterial() {
+    return new three.ShaderMaterial({
+        name: "Clear",
+        uniforms: {
+            map: {
+                value: null
+            },
+            intensity: {
+                value: 1
+            }
+        },
+        vertexShader: vert_fullscreen,
+        fragmentShader: /* glsl */ `
+                uniform sampler2D map;
+                uniform float     intensity;
+                varying vec2 vUv;
+                void main() {
+                    vec4 col = texture2D(map, vUv);
+                    gl_FragColor = vec4(col.rgb * intensity, col.a);
+                }
+            `,
+        blending: three.NoBlending,
+        depthWrite: false,
+        depthTest: false
+    });
+}
+function _getCubeMapMaterial() {
+    return new three.ShaderMaterial({
+        name: "CubeMapToCubeUV",
+        uniforms: {
+            envMap: {
+                value: null
+            },
+            lod: {
+                value: 0
+            }
+        },
+        vertexShader: _getCommonVertexShader(),
+        fragmentShader: /* glsl */ `
+            precision mediump float;
+            precision mediump int;
+
+            varying vec3 vOutputDirection;
+            uniform samplerCube envMap;
+            uniform float       lod;
+
+            void main() {
+                gl_FragColor = textureCubeLodEXT(envMap, vOutputDirection, lod);
+            }
+        `,
+        blending: three.AdditiveBlending,
+        depthWrite: false,
+        depthTest: false
+    });
+}
+function _getMipCopyMaterial(lodMax, width, height) {
+    return new three.ShaderMaterial({
+        name: "MipBlurToCubeUV",
+        defines: {
+            CUBEUV_TEXEL_WIDTH: 1.0 / width,
+            CUBEUV_TEXEL_HEIGHT: 1.0 / height,
+            CUBEUV_MAX_MIP: `${lodMax}.0`
+        },
+        uniforms: {
+            cubeUVMap: {
+                value: null
+            },
+            lod: {
+                value: 0
+            }
+        },
+        vertexShader: _getCommonVertexShader(),
+        fragmentShader: /* glsl */ `
+            precision mediump float;
+            precision mediump int;
+
+            #define ENVMAP_TYPE_CUBE_UV
+            #include <cube_uv_reflection_fragment>
+
+            varying vec3  vOutputDirection;
+
+            uniform sampler2D   cubeUVMap;
+            uniform float       lod;
+
+            void main() {
+                vec3 col = bilinearCubeUV(cubeUVMap, vOutputDirection, CUBEUV_MAX_MIP - lod);
+                gl_FragColor = vec4(col, 1.);
+            }
+        `,
+        blending: three.AdditiveBlending,
+        depthWrite: false,
+        depthTest: false
+    });
+}
+function _getMipBlurMaterial(lodMax, width, height) {
+    return new three.ShaderMaterial({
+        name: "MipBlurToCubeUV",
+        defines: {
+            CUBEUV_TEXEL_WIDTH: 1.0 / width,
+            CUBEUV_TEXEL_HEIGHT: 1.0 / height,
+            CUBEUV_MAX_MIP: `${lodMax}.0`
+        },
+        uniforms: {
+            envMap: {
+                value: null
+            },
+            cubeUVMap: {
+                value: null
+            },
+            weight: {
+                value: 1
+            },
+            lod: {
+                value: 0
+            },
+            exposure: {
+                value: 1
+            }
+        },
+        vertexShader: _getCommonVertexShader(),
+        fragmentShader: /* glsl */ `
+            precision mediump float;
+            precision mediump int;
+
+            #define ENVMAP_TYPE_CUBE_UV
+            #include <cube_uv_reflection_fragment>
+
+            varying vec3  vOutputDirection;
+
+            uniform sampler2D   cubeUVMap;
+            uniform samplerCube envMap;
+            uniform float       weight;
+            uniform float       lod;
+            uniform float       exposure;
+
+            void main() {
+                vec3 col0 = bilinearCubeUV(cubeUVMap, vOutputDirection, CUBEUV_MAX_MIP - (lod + 1.));
+                vec3 col1 = textureCubeLodEXT(envMap, vOutputDirection, lod).rgb * exposure;
+                gl_FragColor = vec4(mix(col0, col1, weight), 1.);
+            }
+        `,
+        blending: three.NoBlending,
+        depthWrite: false,
+        depthTest: false
+    });
+}
+
 class Caller {
     get pause() {
         return this._pause;
@@ -3445,8 +4152,9 @@ ResourceManager._texSettingKeys = [
     "minFilter",
     "format",
     "anisotropy",
+    "repeat",
     "colorSpace",
-    "repeat"
+    "channel"
 ];
 
 function applyProps(target, props) {
@@ -3538,14 +4246,14 @@ class Viewer extends EventEmitter {
         }
         return shadow;
     }
-    static CompileMaterial(renderer, scene, camera, target) {
+    static compileMaterial(renderer, scene, camera, target) {
         Viewer.fullscreenMesh.material = target;
         renderer.compile(Viewer.fullscreenMesh, camera, scene);
     }
-    static CompileObject3D(renderer, scene, camera, target) {
+    static compileObject3D(renderer, scene, camera, target) {
         renderer.compile(target, camera, scene);
     }
-    static CompileTexture(renderer, target) {
+    static compileTexture(renderer, target) {
         if (Array.isArray(target)) {
             for (let v of target){
                 renderer.initTexture(v);
@@ -3561,7 +4269,7 @@ class Viewer extends EventEmitter {
         renderer.render(Viewer.fullscreenMesh, Viewer.fullscreenCamera);
         renderer.setRenderTarget(RT);
     }
-    static GetFullscreenTriangle() {
+    static createFullscreenTriangle() {
         let geometry = new three.BufferGeometry();
         geometry.setAttribute('position', new three.Float32BufferAttribute([
             -1,
@@ -3584,6 +4292,51 @@ class Viewer extends EventEmitter {
         ], 2));
         return geometry;
     }
+    static findChild(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;
+    }
+    static getChildByName(node, name) {
+        return Viewer.getObject(node, (v)=>v.name === name && v);
+    }
+    static getObject(node, filter) {
+        const queue = [
+            node
+        ];
+        while(queue.length !== 0){
+            let object = queue.shift();
+            let target = filter(object);
+            if (target) {
+                return target;
+            }
+            object.children.forEach((v)=>queue.push(v));
+        }
+    }
+    static getObjects(node, filter) {
+        const queue = [
+            node
+        ];
+        const objects = [];
+        while(queue.length !== 0){
+            let object = queue.shift();
+            let target = filter(object);
+            if (target) {
+                objects.push(object);
+            }
+            object.children.forEach((v)=>queue.push(v));
+        }
+        return objects;
+    }
     get root() {
         return this._root;
     }
@@ -3778,16 +4531,12 @@ class Viewer extends EventEmitter {
         this._tweenManager.killTweensOf(target);
     }
     traverseMaterials(callback) {
-        const renderList = this._renderer.renderLists.get(this._scene, 0);
-        const setMaterial = (item)=>{
-            if (item.material) {
+        Viewer.getObjects(this._scene, (item)=>{
+            if (item.isMesh) {
                 if (Array.isArray(item.material)) item.material.forEach(callback);
                 else callback(item.material);
             }
-        };
-        renderList.opaque.forEach(setMaterial);
-        renderList.transparent.forEach(setMaterial);
-        renderList.transmissive.forEach(setMaterial);
+        });
     }
     traversePlugins(callback) {
         return this._pluginManager.traversePlugins(callback);
@@ -3872,7 +4621,7 @@ class Viewer extends EventEmitter {
             minFilter: nearest ? three.NearestFilter : mipmap ? three.LinearMipMapLinearFilter : three.LinearFilter,
             type: typeof floatType === "boolean" ? floatType ? this.DATA_FLOAT_TYPE : three.UnsignedByteType : floatType,
             anisotropy: 0,
-            colorSpace: three.SRGBColorSpace,
+            colorSpace: three.LinearSRGBColorSpace,
             depthBuffer: false,
             stencilBuffer: false,
             samples: SystemInfo.isSupportMSAA ? msaa : 0,
@@ -3887,7 +4636,7 @@ class Viewer extends EventEmitter {
             minFilter: nearest ? three.NearestFilter : mipmap ? three.LinearMipMapLinearFilter : three.LinearFilter,
             type: typeof floatType === "boolean" ? floatType ? this.DATA_FLOAT_TYPE : three.UnsignedByteType : floatType,
             anisotropy: 0,
-            colorSpace: three.SRGBColorSpace,
+            colorSpace: three.LinearSRGBColorSpace,
             depthBuffer: false,
             stencilBuffer: false,
             samples: SystemInfo.isSupportMSAA ? msaa : 0,
@@ -3916,33 +4665,33 @@ class Viewer extends EventEmitter {
     compile(target) {
         if (Array.isArray(target)) {
             if (target.every((v)=>v.isMaterial)) {
-                Viewer.CompileMaterial(this._renderer, this._scene, this._camera, target);
+                Viewer.compileMaterial(this._renderer, this._scene, this._camera, target);
             } else {
                 throw Error("Viewer.compile: unsuport material");
             }
         } else if (typeof target === "object") {
             if (target.isMaterial) {
-                Viewer.CompileMaterial(this._renderer, this._scene, this._camera, target);
+                Viewer.compileMaterial(this._renderer, this._scene, this._camera, target);
             } else if (target.isObject3D) {
                 if (target.meshData.materials) {
-                    Viewer.CompileMaterial(this._renderer, this._scene, this._camera, Object.values(target.meshData.materials));
+                    Viewer.compileMaterial(this._renderer, this._scene, this._camera, Object.values(target.meshData.materials));
                 }
                 if (target.meshData.textures) {
-                    Viewer.CompileTexture(this._renderer, Object.values(target.meshData.textures));
+                    Viewer.compileTexture(this._renderer, Object.values(target.meshData.textures));
                 }
                 if (!target.meshData.meshes) {
-                    Viewer.CompileObject3D(this._renderer, this._scene, this._camera, target);
+                    Viewer.compileObject3D(this._renderer, this._scene, this._camera, target);
                 }
             } else if (target.isTexture) {
-                Viewer.CompileTexture(this._renderer, target);
+                Viewer.compileTexture(this._renderer, target);
             }
         } else {
-            Viewer.CompileObject3D(this._renderer, this._scene, this._camera, this._scene);
+            Viewer.compileObject3D(this._renderer, this._scene, this._camera, this._scene);
         }
     }
     constructor({ root, canvas, autoStart = true, autoResize = true, shadows = false, camera = {
         fov: 45,
-        near: 1,
+        near: 0.1,
         far: 1000,
         position: new three.Vector3(0, 0, 4)
     }, targetFrameRate = -1, colorSpace = three.SRGBColorSpace, toneMapping = three.LinearToneMapping, toneMappingExposure = 1, maxDPR = 1.5, path = "", resourcePath = "", dracoPath = "https://www.gstatic.com/draco/v1/decoders/", loader = {}, tasker = {}, ...webglOpts } = {}){
@@ -3974,7 +4723,7 @@ class Viewer extends EventEmitter {
         this._DATA_FLOAT_TYPE = webgl.DATA_FLOAT_TYPE;
         this._dpr = Math.min(maxDPR, window.devicePixelRatio);
         this._scene = new three.Scene();
-        this._camera = new three.PerspectiveCamera();
+        this._camera = applyProps(new three.PerspectiveCamera(), camera);
         this._renderer = new three.WebGLRenderer({
             canvas: el,
             context: webgl.gl
@@ -4015,23 +4764,455 @@ Viewer._shadowCameraKeys = [
     "near",
     "far"
 ];
-Viewer.fullscreenMesh = new three.Mesh(Viewer.GetFullscreenTriangle());
+Viewer.fullscreenMesh = new three.Mesh(Viewer.createFullscreenTriangle());
 Viewer.fullscreenCamera = new three.OrthographicCamera(-1, 1, 1, -1, 0, 1);
 
-class Plugin extends ObjectInstance {
-    constructor(...args){
-        super(...args);
-        this.type = "Plugin";
+class MergeRefectPass {
+    get envMapTarget() {
+        return this._envMapTarget;
+    }
+    dispose() {
+        this._envMapTarget.dispose();
+        this._pmremGenerator.dispose();
+    }
+    mergeReflect(info) {
+        this._pmremGenerator._clearTexture(this._envMapTarget, this.envMapIntensity);
+        this._pmremGenerator._mergeReflect(this._envMapTarget, this._reflectMap);
+        info.envMapTarget = this._envMapTarget;
+        info.lodMax = this._pmremGenerator._lodMeshes.length - 1;
+    }
+    _getPMREMExtension(renderer) {
+        const pmremGenerator = new three.PMREMGenerator(renderer);
+        pmremGenerator._fromTextureExtension = function(reflectMap, envMap) {
+            const target = envMap ? this._fromTexture(envMap) : this._fromCubeTexture(reflectMap);
+            this._cubeMapMaterial = _getCubeMapMaterial();
+            this._copyTexMaterial = _getClearMaterial();
+            this._copyMesh = new three.Mesh(Viewer.fullscreenMesh.geometry, this._copyTexMaterial);
+            this._lodMeshes = this._lodPlanes.map((v)=>new three.Mesh(v, this._cubeMapMaterial));
+            this._sourceInit = false;
+            return target;
+        };
+        pmremGenerator._fromCubeTexture = function(texture) {
+            this._setSize(texture.image.length === 0 ? 16 : texture.image[0].width || texture.image[0].image.width);
+            return this._allocateTargets();
+        };
+        pmremGenerator._copyTexture = function(targetOut, texture, intensity = 1) {
+            const uniforms = this._copyTexMaterial.uniforms;
+            uniforms.map.value = texture;
+            uniforms.intensity.value = intensity;
+            const renderer = this._renderer;
+            renderer.autoClear = true;
+            renderer.setRenderTarget(targetOut);
+            renderer.render(this._copyMesh, _flatCamera);
+            renderer.setRenderTarget(null);
+        };
+        pmremGenerator._clearTexture = function(targetOut, intensity) {
+            const source = this._pingPongRenderTarget;
+            if (this._sourceInit === false) {
+                this._sourceInit = true;
+                source.scissorTest = false;
+                _setViewport(source, 0, 0, source.width, source.height);
+                this._copyTexture(source, targetOut.texture);
+            } else {
+                this._copyTexture(targetOut, source.texture, intensity);
+            }
+        };
+        pmremGenerator._mergeReflect = function(sourceTarget, reflectMap, clear = false) {
+            const renderer = this._renderer;
+            const autoClear = renderer.autoClear;
+            const cubeMapMaterial = this._cubeMapMaterial;
+            const uniforms = this._cubeMapMaterial.uniforms;
+            uniforms.envMap.value = reflectMap;
+            renderer.autoClear = clear;
+            for(let i = 0; i < this._lodMeshes.length - 1; i++){
+                uniforms.lod.value = i < 5 ? 0 : i;
+                this._blit(sourceTarget, i, cubeMapMaterial);
+            }
+            sourceTarget.scissorTest = false;
+            _setViewport(sourceTarget, 0, 0, sourceTarget.width, sourceTarget.height);
+            renderer.autoClear = autoClear;
+        };
+        pmremGenerator._blit = function(targetOut, lodOut, material) {
+            const renderer = this._renderer;
+            const _lodMax = this._lodMax;
+            const outputSize = this._sizeLods[lodOut];
+            const x = 3 * outputSize * (lodOut > _lodMax - LOD_MIN ? lodOut - _lodMax + LOD_MIN : 0);
+            const y = 4 * (this._cubeSize - outputSize);
+            _setViewport(targetOut, x, y, 3 * outputSize, 2 * outputSize);
+            const lodMesh = this._lodMeshes[lodOut];
+            lodMesh.material = material;
+            renderer.autoClear = false;
+            renderer.setRenderTarget(targetOut);
+            renderer.render(lodMesh, _flatCamera);
+        };
+        return pmremGenerator;
+    }
+    constructor({ envMap, reflectMap, viewer }){
+        this.envMapIntensity = 1;
+        this._reflectMap = reflectMap;
+        this._pmremGenerator = this._getPMREMExtension(viewer.renderer);
+        this._envMapTarget = this._pmremGenerator._fromTextureExtension(reflectMap, envMap);
+        viewer.scene.environment = this._envMapTarget.texture;
+    }
+}
+
+function mipGaussianBlendWeight(sigma, lod) {
+    let sigma2 = sigma * sigma;
+    let c = 2.0 * Math.PI * sigma2;
+    let numerator = Math.pow(16, lod) * 1.386294361; //log(4)
+    let denorminator = c * (Math.pow(4, lod) + c);
+    return three.MathUtils.clamp(numerator / denorminator, 0, 1);
+}
+
+const MAX_LOD = 10;
+class MergeMipBlurPass {
+    get blurIntensity() {
+        return this._blurIntensity;
+    }
+    set blurIntensity(v) {
+        if (this._blurIntensity !== v) {
+            this._blurIntensity = v;
+            this._sigma = three.MathUtils.lerp(1, 40, this._blurIntensity / 10);
+            for(let lod = 0; lod <= MAX_LOD; lod++){
+                let w = mipGaussianBlendWeight(this._sigma, lod);
+                if (w < 0.002) {
+                    this._blurMinLod = lod;
+                }
+                if (w >= 1) {
+                    this._blurMaxLod = lod;
+                    break;
+                }
+            }
+        }
+    }
+    get envMapTarget() {
+        return this._envMapTarget;
+    }
+    dispose() {
+        this._envMapTarget.dispose();
+        this._pmremGenerator.dispose();
+    }
+    mergeMipBlur(info) {
+        const targetIn = this._pmremGenerator._applyMipBlur(this._envMapTarget, this._reflectMap, this._blurMinLod, this._blurMaxLod, this._sigma, this.exposure);
+        this._pmremGenerator._mipCopy(info.envMapTarget, targetIn, info.lodMax, this._blurMinLod);
+    }
+    _getPMREMExtension(renderer) {
+        const pmremGenerator = new three.PMREMGenerator(renderer);
+        pmremGenerator._fromTextureExtension = function(texture) {
+            this._setSize(texture.image.length === 0 ? 16 : texture.image[0].width || texture.image[0].image.width);
+            const target = this._allocateTargets();
+            this._mipBlurMaterial = _getMipBlurMaterial(this._lodMax, target.width, target.height);
+            this._mipCopyMaterial = _getMipCopyMaterial(this._lodMax, target.width, target.height);
+            this._lodMeshes = this._lodPlanes.map((v)=>new three.Mesh(v, this._mipBlurMaterial));
+            return target;
+        };
+        pmremGenerator._applyMipBlur = function(sourceTarget, texture, blurMinLod, blurMaxLod, sigma, exposure) {
+            const pingPongRenderTarget = this._pingPongRenderTarget;
+            const uniforms = this._mipBlurMaterial.uniforms;
+            uniforms.envMap.value = texture;
+            uniforms.exposure.value = exposure;
+            let lod = blurMaxLod;
+            let targetOut = sourceTarget;
+            let targetIn = pingPongRenderTarget;
+            this._mipBlur(sourceTarget, pingPongRenderTarget, lod, 1);
+            for(let i = 0; lod-- > blurMinLod; i++){
+                targetOut = (i & 1) === 0 ? pingPongRenderTarget : sourceTarget;
+                targetIn = (i & 1) === 1 ? pingPongRenderTarget : sourceTarget;
+                this._mipBlur(targetOut, targetIn, lod, mipGaussianBlendWeight(sigma, lod));
+            }
+            sourceTarget.scissorTest = false;
+            _setViewport(sourceTarget, 0, 0, sourceTarget.width, sourceTarget.height);
+            return targetOut;
+        };
+        pmremGenerator._mipBlur = function(targetOut, targetIn, lodOut, weight) {
+            const uniforms = this._mipBlurMaterial.uniforms;
+            uniforms.cubeUVMap.value = targetIn.texture;
+            uniforms.weight.value = weight;
+            uniforms.lod.value = lodOut;
+            this._blit(targetOut, lodOut, this._mipBlurMaterial);
+        };
+        pmremGenerator._mipCopy = function(targetOut, targetIn, lodOut, lodIn = lodOut) {
+            const uniforms = this._mipCopyMaterial.uniforms;
+            uniforms.cubeUVMap.value = targetIn.texture;
+            uniforms.lod.value = lodIn;
+            this._blit(targetOut, lodOut, this._mipCopyMaterial);
+            targetOut.scissorTest = false;
+            _setViewport(targetOut, 0, 0, targetOut.width, targetOut.height);
+        };
+        pmremGenerator._blit = function(targetOut, lodOut, material) {
+            const renderer = this._renderer;
+            const _lodMax = this._lodMax;
+            const outputSize = this._sizeLods[lodOut];
+            const x = 3 * outputSize * (lodOut > _lodMax - LOD_MIN ? lodOut - _lodMax + LOD_MIN : 0);
+            const y = 4 * (this._cubeSize - outputSize);
+            _setViewport(targetOut, x, y, 3 * outputSize, 2 * outputSize);
+            const lodMesh = this._lodMeshes[lodOut];
+            lodMesh.material = material;
+            renderer.autoClear = false;
+            renderer.setRenderTarget(targetOut);
+            renderer.render(lodMesh, _flatCamera);
+        };
+        return pmremGenerator;
+    }
+    constructor({ viewer, reflectMap }){
+        this._sigma = 2;
+        this._blurMinLod = 0;
+        this._blurMaxLod = MAX_LOD;
+        this._blurIntensity = -1;
+        this.exposure = 1;
+        this._reflectMap = reflectMap;
+        this._pmremGenerator = this._getPMREMExtension(viewer.renderer);
+        this._envMapTarget = this._pmremGenerator._fromTextureExtension(reflectMap);
+    }
+}
+
+class EnvironmentPlugin extends Plugin {
+    get debug() {
+        return this._debug;
+    }
+    set debug(v) {
+        if (this._debug !== v) {
+            this._debug = v;
+            if (v) {
+                if (this._debugNode === null) {
+                    const viewer = this.viewer;
+                    const debugScene = DebugPlugin.Instance(viewer).scene;
+                    this._debugNode = viewer.addNode(three.Object3D, {
+                        parent: debugScene
+                    });
+                    viewer.addNode(Plane, {
+                        parent: this._debugNode,
+                        material: new three.MeshBasicMaterial({
+                            map: this._reflectPass.envMapTarget.texture
+                        }),
+                        position: new three.Vector3(1.1, 3, 0)
+                    });
+                    viewer.addNode(Plane, {
+                        parent: this._debugNode,
+                        material: new three.MeshBasicMaterial({
+                            map: this._mipBlurPass.envMapTarget.texture
+                        }),
+                        position: new three.Vector3(0, 3, 0)
+                    });
+                }
+            }
+            if (this._debugNode) {
+                this._debugNode.visible = v;
+            }
+        }
+    }
+    onRender() {
+        const { renderer } = this.viewer;
+        const autoClear = renderer.autoClear;
+        const oldTarget = renderer.getRenderTarget();
+        const oldActiveCubeFace = renderer.getActiveCubeFace();
+        const oldActiveMipmapLevel = renderer.getActiveMipmapLevel();
+        this._reflectPass.envMapIntensity = this.envMapIntensity;
+        this._mipBlurPass.exposure = this.reflectExposure;
+        this._mipBlurPass.blurIntensity = this.reflectBlurIntensity;
+        this._cubeCamera.update(renderer, this._scene);
+        this._reflectPass.mergeReflect(this._mergeInfo);
+        this._mipBlurPass.mergeMipBlur(this._mergeInfo);
+        renderer.autoClear = autoClear;
+        renderer.setRenderTarget(oldTarget, oldActiveCubeFace, oldActiveMipmapLevel);
+    }
+    constructor({ envMap, scene, near, far, layer = 0, resolution = 256, floatType = three.HalfFloatType, position = new three.Vector3(0, 1, 0) } = {}){
+        super();
+        this._mergeInfo = {
+            envMapTarget: null,
+            lodMax: 0
+        };
+        this._debug = false;
+        this._debugNode = null;
+        this.envMapIntensity = 1;
+        this.reflectExposure = 1;
+        this.reflectBlurIntensity = 5;
+        this.install = ()=>{
+            const viewer = this.viewer;
+            this._scene = scene || viewer.scene;
+            const cubeRenderTarget = viewer.createCubeRenderTarget(resolution, false, floatType, 0, true);
+            this._cubeCamera = new three.CubeCamera(near || viewer.camera.near, far || viewer.camera.far, cubeRenderTarget);
+            this._cubeCamera.position.copy(position);
+            this._cubeCamera.layers.set(layer);
+            const reflectMap = cubeRenderTarget.texture;
+            this._reflectPass = new MergeRefectPass({
+                viewer,
+                reflectMap,
+                envMap
+            });
+            this._mipBlurPass = new MergeMipBlurPass({
+                viewer,
+                reflectMap
+            });
+        };
+        this.uninstall = ()=>{
+            this._reflectPass.dispose();
+            this._mipBlurPass.dispose();
+        };
     }
 }
+__decorate([
+    property
+], EnvironmentPlugin.prototype, "debug", null);
+__decorate([
+    property({
+        min: 0,
+        max: 1,
+        step: 0.01
+    })
+], EnvironmentPlugin.prototype, "envMapIntensity", void 0);
+__decorate([
+    property({
+        min: 0,
+        max: 10,
+        step: 0.01
+    })
+], EnvironmentPlugin.prototype, "reflectExposure", void 0);
+__decorate([
+    property({
+        min: 0,
+        max: 10,
+        step: 0.1
+    })
+], EnvironmentPlugin.prototype, "reflectBlurIntensity", void 0);
+
+class BoxProjectionPlugin extends Plugin {
+    get debug() {
+        return this._debug;
+    }
+    set debug(v) {
+        if (this._debug !== v) {
+            this._debug = v;
+            if (v) {
+                if (this._helper === null) {
+                    this._helper = new three.Box3Helper(new three.Box3(this._boxMin, this._boxMax));
+                    DebugPlugin.Instance(this.viewer).add(this._helper);
+                }
+            }
+            if (this._helper) {
+                this._helper.visible = v;
+            }
+        }
+    }
+    get center() {
+        return this._center;
+    }
+    set center(v) {
+        this._center.copy(v);
+    }
+    get boxMin() {
+        return this._boxMin;
+    }
+    set boxMin(v) {
+        this._boxMin.copy(v);
+    }
+    get boxMax() {
+        return this._boxMax;
+    }
+    set boxMax(v) {
+        this._boxMax.copy(v);
+    }
+    onUpdate(dt) {
+        if (this._debug) {
+            this._helper.updateMatrixWorld();
+        }
+    }
+    useBoxProjection(shader) {
+        shader.defines.USE_BOX_PROJECTION = true;
+        shader.uniforms.probePos = {
+            value: this._center
+        };
+        shader.uniforms.probeBoxMin = {
+            value: this._boxMin
+        };
+        shader.uniforms.probeBoxMax = {
+            value: this._boxMax
+        };
+    }
+    constructor(){
+        super();
+        this._center = new three.Vector4(0, 0.5, 0, 1);
+        this._boxMin = new three.Vector3(0, 0, 0);
+        this._boxMax = new three.Vector3(1, 1, 1);
+        this._helper = null;
+        this._debug = false;
+        this.install = ()=>{
+            three.ShaderLib.physical.vertexShader = three.ShaderLib.physical.vertexShader.replace(/#ifdef USE_TRANSMISSION/g, `
+            #if defined(USE_TRANSMISSION) || defined(USE_BOX_PROJECTION)
+            `);
+            three.ShaderLib.physical.fragmentShader = three.ShaderLib.physical.fragmentShader.replace("varying vec3 vViewPosition;", `
+            varying vec3 vViewPosition;
+            #if defined(USE_BOX_PROJECTION)
+            varying vec3 vWorldPosition;
+            #endif
+            `);
+            three.ShaderChunk.worldpos_vertex = three.ShaderChunk.worldpos_vertex.replace("#if defined( USE_ENVMAP )", "#if defined( USE_ENVMAP ) || defined( USE_BOX_PROJECTION )");
+            three.ShaderChunk.envmap_physical_pars_fragment = three.ShaderChunk.envmap_physical_pars_fragment.replace("#ifdef USE_ENVMAP", `
+            #ifdef USE_ENVMAP
+
+            #if defined(USE_BOX_PROJECTION)
+            uniform vec4 probePos;
+            uniform vec3 probeBoxMin;
+            uniform vec3 probeBoxMax;
+            
+            vec3 boxProjection(vec3 nrdir, vec3 worldPos, vec3 probePos, vec3 boxMin, vec3 boxMax) {
+                vec3 tbot = boxMin - worldPos;
+                vec3 ttop = boxMax - worldPos;
+                vec3 tmax = mix(tbot, ttop, step(vec3(0), nrdir));
+                tmax /= nrdir;
+                float t = min(min(tmax.x, tmax.y), tmax.z);
+                return worldPos + nrdir * t - probePos;
+            }
+            #endif
+
+            `).replace("reflectVec = inverseTransformDirection( reflectVec, viewMatrix );", `
+            reflectVec = inverseTransformDirection( reflectVec, viewMatrix );
+            
+            #if defined(USE_BOX_PROJECTION)
+            if (probePos.w > 0.001) {
+                reflectVec = boxProjection(reflectVec, vWorldPosition, probePos.xyz, probeBoxMin.xyz, probeBoxMax.xyz);
+            }
+            #endif
+
+            `).replace("vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );", `
+            vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
+
+            #if defined(USE_BOX_PROJECTION)
+            if (probePos.w > 0.001) {
+                worldNormal = boxProjection(worldNormal, vWorldPosition, probePos.xyz, probeBoxMin.xyz, probeBoxMax.xyz);
+            }
+            #endif
+
+            `);
+        };
+        this.uninstall = ()=>{
+            DebugPlugin.Instance(this.viewer).remove(this._helper);
+        };
+    }
+}
+__decorate([
+    property
+], BoxProjectionPlugin.prototype, "debug", null);
+__decorate([
+    property
+], BoxProjectionPlugin.prototype, "center", null);
+__decorate([
+    property
+], BoxProjectionPlugin.prototype, "boxMin", null);
+__decorate([
+    property
+], BoxProjectionPlugin.prototype, "boxMax", null);
 
 exports.AnimationCurve = AnimationCurve;
 exports.Box = Box;
+exports.BoxProjectionPlugin = BoxProjectionPlugin;
 exports.CinestationBlendDefinition = CinestationBlendDefinition;
 exports.CinestationBrain = CinestationBrain;
 exports.Component = Component;
+exports.DebugPlugin = DebugPlugin;
 exports.DeviceInput = DeviceInput;
 exports.Easing = Easing;
+exports.EnvironmentPlugin = EnvironmentPlugin;
 exports.EventEmitter = EventEmitter;
 exports.FInterpConstantTo = FInterpConstantTo;
 exports.FInterpTo = FInterpTo;
@@ -4049,6 +5230,8 @@ exports.Quat_Equals = Quat_Equals;
 exports.Quat_exponentialDamp = Quat_exponentialDamp;
 exports.Quat_quarticDamp = Quat_quarticDamp;
 exports.Quat_smoothDamp = Quat_smoothDamp;
+exports.Reflector = Reflector;
+exports.ReflectorMaterial = ReflectorMaterial;
 exports.Sphere = Sphere;
 exports.SystemInfo = SystemInfo;
 exports.Tween = Tween;
@@ -4075,9 +5258,14 @@ exports.aJSONLoader = aJSONLoader;
 exports.aLoader = aLoader;
 exports.aTextureLoader = aTextureLoader;
 exports.exponentialDamp = exponentialDamp;
+exports.frag_BoxfilterBlur = frag_BoxfilterBlur;
+exports.frag_cubeMapToPanorama = frag_cubeMapToPanorama;
+exports.frag_panoramaToCubeMap = frag_panoramaToCubeMap;
 exports.getClassInstance = getClassInstance;
+exports.getShaderMaterial = getShaderMaterial;
 exports.mixin = mixin;
 exports.property = property;
 exports.quarticDamp = quarticDamp;
 exports.smoothDamp = smoothDamp;
+exports.vert_fullscreen = vert_fullscreen;
 //# sourceMappingURL=main.js.map