@xviewer.js/core 1.0.5-alhpa.2 → 1.0.5-alhpa.3

package/dist/module.js

@@ -4,7 +4,7 @@ import { GLTFLoader as GLTFLoader$1 } from 'three/examples/jsm/loaders/GLTFLoade
 import { DRACOLoader } from 'three/examples/jsm/loaders/DRACOLoader.js';
 import { MeshoptDecoder } from 'three/examples/jsm/libs/meshopt_decoder.module.js';
 import * as THREE from 'three';
-import { EquirectangularReflectionMapping, FileLoader, TextureLoader as TextureLoader$1, SRGBColorSpace, CubeUVReflectionMapping, Mesh, BoxGeometry, SphereGeometry, PlaneGeometry, MathUtils, Vector3, Vector2, LinearInterpolant, Object3D, Plane as Plane$1, Matrix4, Vector4, PerspectiveCamera, WebGLRenderTarget, LinearMipMapLinearFilter, LinearFilter, HalfFloatType, AnimationMixer, Color, OrthographicCamera, MeshDepthMaterial, ShaderMaterial, Euler, Group, REVISION, Box3, Sphere as Sphere$1, Raycaster, Quaternion, Spherical, UniformsUtils, NoBlending, AdditiveBlending, FloatType, UnsignedByteType, LinearSRGBColorSpace, NearestFilter, ClampToEdgeWrapping, WebGLCubeRenderTarget, DataTexture, RGBAFormat, UVMapping, BufferGeometry, Float32BufferAttribute, Scene, WebGLRenderer, LinearToneMapping, PCFSoftShadowMap, LoadingManager, PMREMGenerator, CubeCamera, ShaderLib, ShaderChunk, BufferAttribute, NormalBlending } from 'three';
+import { EquirectangularReflectionMapping, FileLoader, TextureLoader as TextureLoader$1, SRGBColorSpace, CubeUVReflectionMapping, Mesh, BoxGeometry, SphereGeometry, PlaneGeometry, MathUtils, Vector3, Vector2, LinearInterpolant, Object3D, Matrix4, Plane as Plane$1, Vector4, PerspectiveCamera, WebGLRenderTarget, LinearMipMapLinearFilter, LinearFilter, HalfFloatType, AnimationMixer, Color, OrthographicCamera, MeshDepthMaterial, ShaderMaterial, Euler, Group, REVISION, Box3, Sphere as Sphere$1, Raycaster, Quaternion, Spherical, UniformsUtils, NoBlending, AdditiveBlending, FloatType, UnsignedByteType, LinearSRGBColorSpace, NearestFilter, ClampToEdgeWrapping, WebGLCubeRenderTarget, DataTexture, RGBAFormat, UVMapping, BufferGeometry, Float32BufferAttribute, Scene, WebGLRenderer, LinearToneMapping, PCFSoftShadowMap, LoadingManager, PMREMGenerator, CubeCamera, ShaderLib, ShaderChunk, BufferAttribute, NormalBlending } from 'three';
 import { HDRLoader as HDRLoader$1 } from 'three/examples/jsm/loaders/HDRLoader.js';
 import { SVGLoader as SVGLoader$1 } from 'three/examples/jsm/loaders/SVGLoader.js';
 import { KTX2Loader as KTX2Loader$1 } from 'three/examples/jsm/loaders/KTX2Loader.js';
@@ -253,10 +253,28 @@ class GLTFLoader extends Loader {
         loader.manager = manager;
         loader.setPath(path);
         loader.setResourcePath(resourcePath);
+        const cb = (gltf)=>{
+            const meshes = new Map();
+            const materials = new Map();
+            gltf.scene.traverse((mesh)=>{
+                if (mesh.isMesh) {
+                    gltf.mesh = mesh;
+                    gltf.material = mesh.material;
+                    meshes.set(mesh.name, mesh);
+                    const arr = Array.isArray(mesh.material) ? mesh.material : [
+                        mesh.material
+                    ];
+                    arr.forEach((m)=>materials.set(m.name, m));
+                }
+            });
+            gltf.meshes = meshes;
+            gltf.materials = materials;
+            onLoad(gltf);
+        };
         if (buffer) {
-            loader.parse(buffer, resourcePath, onLoad, onError);
+            loader.parse(buffer, resourcePath, cb, onError);
         } else {
-            loader.load(url, onLoad, onProgress, onError);
+            loader.load(url, cb, onProgress, onError);
         }
     }
     constructor(...args){
@@ -1310,8 +1328,17 @@ class Component extends ObjectInstance {
 }
 
 class Reflector extends Component {
+    get texture() {
+        return this._renderTarget.texture;
+    }
+    get textureMatrix() {
+        return this._textureMatrix;
+    }
+    onDestroy() {
+        this._renderTarget.dispose();
+    }
     constructor({ resolution = 512, clipBias = 0, multisample = 4, layerMask = 1 << 0, normal = new Vector3(0, 1, 0), mipmap = false } = {}){
-        super(), this.node = new Object3D(), this.layerMask = 1 << 0;
+        super(), this.node = new Object3D(), this.layerMask = 1 << 0, this._renderTarget = null, this._textureMatrix = new Matrix4();
         this.layerMask = layerMask;
         const reflectorPlane = new Plane$1();
         const reflectorNormal = new Vector3();
@@ -1323,15 +1350,14 @@ class Reflector extends Component {
         const view = new Vector3();
         const target = new Vector3();
         const q = new Vector4();
-        const textureMatrix = new Matrix4();
         const virtualCamera = new PerspectiveCamera();
-        const renderTarget = new WebGLRenderTarget(resolution, resolution, {
+        this._renderTarget = new WebGLRenderTarget(resolution, resolution, {
             samples: multisample,
             type: HalfFloatType,
             minFilter: mipmap ? LinearMipMapLinearFilter : LinearFilter,
             generateMipmaps: mipmap
         });
-        const update = ()=>{
+        this.lastUpdate = ()=>{
             const node = this.node;
             const { renderer, camera, scene } = this.context;
             reflectorWorldPosition.setFromMatrixPosition(node.matrixWorld);
@@ -1362,9 +1388,9 @@ class Reflector extends Component {
             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);
+            this.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);
+            this.textureMatrix.multiply(virtualCamera.projectionMatrix);
+            this.textureMatrix.multiply(virtualCamera.matrixWorldInverse);
             // 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(reflectorNormal, reflectorWorldPosition);
@@ -1393,7 +1419,7 @@ class Reflector extends Component {
             renderer.shadowMap.autoUpdate = false; // Avoid re-computing shadows
             const clearAlpha = renderer.getClearAlpha();
             renderer.setClearAlpha(0);
-            renderer.setRenderTarget(renderTarget);
+            renderer.setRenderTarget(this._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);
@@ -1408,10 +1434,6 @@ class Reflector extends Component {
             }
             node.visible = true;
         };
-        this.lastUpdate = update;
-        this.onDestroy = ()=>renderTarget.dispose();
-        this.getRenderTarget = ()=>renderTarget;
-        this.getTextureMatrix = ()=>textureMatrix;
     }
 }
 
@@ -3120,6 +3142,13 @@ const { tan, PI } = Math;
 const PI2 = PI * 2;
 const ESP = 0.001;
 class FreelookVirtualCamera extends Component {
+    get up() {
+        return this._up;
+    }
+    set up(v) {
+        this._up.copy(v);
+        this._targetUp.copy(v);
+    }
     get lookAt() {
         return this._lookAt;
     }
@@ -3134,11 +3163,11 @@ class FreelookVirtualCamera extends Component {
         this._offset.copy(v);
         this._targetOffset.copy(v);
     }
-    get springLength() {
+    get radius() {
         return this._spherical.radius;
     }
-    set springLength(v) {
-        this._spherical.radius = this._targetSpringLength = clamp(v, this.distanceMin, this.distanceMax);
+    set radius(v) {
+        this._spherical.radius = this._targetRadius = clamp(v, this.radiusMin, this.radiusMax);
     }
     get theta() {
         return this._spherical.theta;
@@ -3190,18 +3219,20 @@ class FreelookVirtualCamera extends Component {
         this._targetFar = this.far;
         this._targetTheta = this.theta;
         this._targetPhi = this.phi;
-        this._targetSpringLength = this.springLength;
+        this._targetRadius = this.radius;
         this._targetLookAt.copy(this._lookAt);
+        this._targetUp.copy(this._up);
     }
-    goto({ phi = this._targetPhi, theta = this._targetTheta, springLength = this._targetSpringLength, offset = this._targetOffset, lookAt = this._lookAt, fov = this._fov, near = this._near, far = this._far, smoothing = this.smoothing, rotateSmoothing = this.smoothing }) {
+    goto({ phi = this._targetPhi, theta = this._targetTheta, radius = this._targetRadius, offset = this._targetOffset, lookAt = this._lookAt, up = this._up, fov = this._fov, near = this._near, far = this._far, smoothing = this.smoothing, rotateSmoothing = this.smoothing }) {
         const t0 = this._spherical.theta = this._spherical.theta % PI2;
         const t1 = theta % PI2;
         const delta = MathUtils.euclideanModulo(t1 - t0 + Math.PI, PI2) - Math.PI;
         this._targetTheta = clamp(t0 + delta, this.thetaMin, this.thetaMax);
         this._targetPhi = clamp(phi, this.phiMin, this.phiMax);
-        this._targetSpringLength = clamp(springLength, this.distanceMin, this.distanceMax);
+        this._targetRadius = clamp(radius, this.radiusMin, this.radiusMax);
         this._targetLookAt.copy(lookAt);
         this._targetOffset.copy(offset);
+        this._targetUp.copy(up);
         this._targetFov = fov;
         this._targetNear = near;
         this._targetFar = far;
@@ -3210,7 +3241,9 @@ class FreelookVirtualCamera extends Component {
     }
     update(dt) {
         this._lerpCamera(dt);
-        this._syncCamera();
+        if (this.sync) {
+            this._syncCamera();
+        }
     }
     _onPointerDown(e) {
         if (SystemInfo.isMobile) return;
@@ -3262,7 +3295,7 @@ class FreelookVirtualCamera extends Component {
     }
     _calculateDistanceScale(scale) {
         this._tempRotateSmoothing = this.rotateSmoothing;
-        if (this.forbidZ) {
+        if (this.forbitAll || this.forbidZ) {
             scale = 1;
         }
         return this._onDistanceScale(scale);
@@ -3271,10 +3304,10 @@ class FreelookVirtualCamera extends Component {
         this._tempRotateSmoothing = this.rotateSmoothing;
         out.copy(loc1).sub(loc0).multiplyScalar(this.rotateSpeed * 2 * Math.PI / this.viewer.height);
         out.y = -out.y;
-        if (this.forbidX) {
+        if (this.forbitAll || this.forbidX) {
             out.x = 0;
         }
-        if (this.forbidY) {
+        if (this.forbitAll || this.forbidY) {
             out.y = 0;
         }
         return out;
@@ -3282,10 +3315,10 @@ class FreelookVirtualCamera extends Component {
     _calculatePanDelta(out, loc0, loc1) {
         this._tempRotateSmoothing = this.rotateSmoothing;
         this._onCalculatePan(out, loc0, loc1);
-        if (this.forbidPanX) {
+        if (this.forbitAll || this.forbidPanX) {
             out.x = 0;
         }
-        if (this.forbidPanY) {
+        if (this.forbitAll || this.forbidPanY) {
             out.y = 0;
         }
         return out;
@@ -3294,7 +3327,7 @@ class FreelookVirtualCamera extends Component {
         const { xAxis, yAxis, posDelta } = FreelookVirtualCamera;
         xAxis.setFromMatrixColumn(this.node.matrix, 0);
         yAxis.setFromMatrixColumn(this.node.matrix, 1);
-        if (this.forbitPanOffsetY) {
+        if (this.forbitAll || this.forbitPanOffsetY) {
             yAxis.y = 0;
             yAxis.normalize();
         }
@@ -3317,11 +3350,11 @@ class FreelookVirtualCamera extends Component {
         this._targetPosition.y += panOffset.y;
     }
     _setTargetSpringLength(scale) {
-        this._targetSpringLength *= scale;
-        this._targetSpringLength = clamp(this._targetSpringLength, this.distanceMin, this.distanceMax);
+        this._targetRadius *= scale;
+        this._targetRadius = clamp(this._targetRadius, this.radiusMin, this.radiusMax);
     }
     constructor(){
-        super(), this._button = -1, this._touchID = -1, this._preLoc0 = new Vector2(), this._preLoc1 = new Vector2(), this._spherical = new Spherical(4, Math.PI / 2), this._lookAt = new Vector3(), this._offset = new Vector2(), this._fov = 45, this._near = 0.1, this._far = 1000, this._tempSmoothing = 6, this._tempRotateSmoothing = 8, this._targetPosition = new Vector3(), this._targetTheta = 0, this._targetPhi = 0, this._targetSpringLength = 4, this._targetFov = this._fov, this._targetNear = this._near, this._targetFar = this._far, this._targetLookAt = new Vector3(), this._targetOffset = new Vector2(), this._finalLookAt = new Vector3(), this.name = "FreelookVirtualCamera", this.forbidX = false, this.forbidY = false, this.forbidZ = false, this.forbidPanX = false, this.forbidPanY = false, this.forbitPanOffsetY = false, this.panSpeed = 1, this.rotateSpeed = 1, this.smoothing = 5, this.rotateSmoothing = 8, this.phiMin = ESP, this.phiMax = Math.PI - ESP, this.thetaMin = -Infinity, this.thetaMax = Infinity, this.distanceMin = ESP, this.distanceMax = Infinity;
+        super(), this._button = -1, this._touchID = -1, this._preLoc0 = new Vector2(), this._preLoc1 = new Vector2(), this._spherical = new Spherical(4, Math.PI / 2), this._lookAt = new Vector3(), this._up = new Vector3(0, 1, 0), this._offset = new Vector2(), this._fov = 45, this._near = 0.1, this._far = 1000, this._tempSmoothing = 6, this._tempRotateSmoothing = 8, this._targetPosition = new Vector3(), this._targetTheta = 0, this._targetPhi = 0, this._targetRadius = 4, this._targetFov = this._fov, this._targetNear = this._near, this._targetFar = this._far, this._targetLookAt = new Vector3(), this._targetOffset = new Vector2(), this._targetUp = new Vector3(0, 1, 0), this._finalLookAt = new Vector3(), this.name = "FreelookVirtualCamera", this.sync = true, this.forbitAll = false, this.forbidX = false, this.forbidY = false, this.forbidZ = false, this.forbidPanX = false, this.forbidPanY = false, this.forbitPanOffsetY = false, this.panSpeed = 1, this.rotateSpeed = 1, this.smoothing = 5, this.rotateSmoothing = 8, this.phiMin = ESP, this.phiMax = Math.PI - ESP, this.thetaMin = -Infinity, this.thetaMax = Infinity, this.radiusMin = ESP, this.radiusMax = Infinity;
         this.node = new Object3D();
         this.node.isCamera = true;
         this.onLoad = ()=>{
@@ -3364,10 +3397,12 @@ class FreelookVirtualCamera extends Component {
                     const rotateSmoothing = this._tempRotateSmoothing;
                     this._spherical.theta = FInterpTo(this._spherical.theta, this._targetTheta, dt, rotateSmoothing);
                     this._spherical.phi = FInterpTo(this._spherical.phi, this._targetPhi, dt, rotateSmoothing);
-                    this._spherical.radius = FInterpTo(this._spherical.radius, this._targetSpringLength, dt, smoothing);
+                    this._spherical.radius = FInterpTo(this._spherical.radius, this._targetRadius, dt, smoothing);
                     VInterpTo(this._lookAt, this._targetLookAt, dt, smoothing);
                     VInterpTo(this._offset, this._targetOffset, dt, smoothing);
+                    VInterpTo(this._up, this._targetUp, dt, smoothing);
                     this._calculateLookAtOffset(this._offset, this._finalLookAt).add(this._lookAt);
+                    this.node.up.copy(this._up);
                     this.node.position.setFromSpherical(this._spherical).add(this._finalLookAt);
                     this.node.lookAt(this._finalLookAt);
                     this._fov = FInterpTo(this._fov, this._targetFov, dt, smoothing);
@@ -3387,7 +3422,7 @@ class FreelookVirtualCamera extends Component {
                     }
                 };
             } else if (camera instanceof OrthographicCamera) {
-                this.springLength = camera.zoom;
+                this.radius = camera.zoom;
                 this._onDistanceScale = (scale)=>{
                     return 1 / scale;
                 };
@@ -3417,7 +3452,7 @@ class FreelookVirtualCamera extends Component {
                     const smoothing = this._tempSmoothing;
                     this.node.position.x = FInterpTo(this.node.position.x, this._targetPosition.x, dt, smoothing);
                     this.node.position.y = FInterpTo(this.node.position.y, this._targetPosition.y, dt, smoothing);
-                    this._spherical.radius = FInterpTo(this._spherical.radius, this._targetSpringLength, dt, smoothing);
+                    this._spherical.radius = FInterpTo(this._spherical.radius, this._targetRadius, dt, smoothing);
                 };
                 this._syncCamera = ()=>{
                     const { zoom } = camera;
@@ -3443,6 +3478,14 @@ FreelookVirtualCamera.lookAtOffset = new Vector3();
 FreelookVirtualCamera.xAxis = new Vector3();
 FreelookVirtualCamera.yAxis = new Vector3();
 FreelookVirtualCamera.quat = new Quaternion();
+__decorate([
+    property
+], FreelookVirtualCamera.prototype, "sync", void 0);
+__decorate([
+    property({
+        dir: "set"
+    })
+], FreelookVirtualCamera.prototype, "forbitAll", void 0);
 __decorate([
     property({
         dir: "set"
@@ -3526,24 +3569,33 @@ __decorate([
         dir: "set",
         step: 0.01
     })
-], FreelookVirtualCamera.prototype, "distanceMin", void 0);
+], FreelookVirtualCamera.prototype, "radiusMin", void 0);
 __decorate([
     property({
         dir: "set",
         step: 0.01
     })
-], FreelookVirtualCamera.prototype, "distanceMax", void 0);
+], FreelookVirtualCamera.prototype, "radiusMax", void 0);
 __decorate([
-    property
+    property({
+        step: 0.01
+    })
+], FreelookVirtualCamera.prototype, "up", null);
+__decorate([
+    property({
+        step: 0.01
+    })
 ], FreelookVirtualCamera.prototype, "lookAt", null);
 __decorate([
-    property
+    property({
+        step: 0.01
+    })
 ], FreelookVirtualCamera.prototype, "offset", null);
 __decorate([
     property({
         step: 0.01
     })
-], FreelookVirtualCamera.prototype, "springLength", null);
+], FreelookVirtualCamera.prototype, "radius", null);
 __decorate([
     property({
         step: 0.01
@@ -4020,8 +4072,8 @@ class ReflectorMaterial extends ShaderMaterial {
             get: ()=>this.uniforms.opacity.value,
             set: (v)=>this.uniforms.opacity.value = v
         });
-        this.uniforms.reflectMap.value = reflector.getRenderTarget().texture;
-        this.uniforms.textureMatrix.value = reflector.getTextureMatrix();
+        this.uniforms.reflectMap.value = reflector.texture;
+        this.uniforms.textureMatrix.value = reflector.textureMatrix;
         this.setValues(parameters);
     }
 }
@@ -4738,6 +4790,12 @@ class Viewer extends EventEmitter {
     get renderer() {
         return this._renderer;
     }
+    get freeze() {
+        return this._freeze;
+    }
+    set freeze(v) {
+        this._freeze = v;
+    }
     destroy() {
         this.stop();
         this._renderer.dispose();
@@ -4769,7 +4827,9 @@ class Viewer extends EventEmitter {
                 dt = Math.min(dt, 0.067);
                 this._renderer.info.reset();
                 this._componentManager.update(dt);
-                this._componentManager.render(dt);
+                if (!this._freeze) {
+                    this._componentManager.render(dt);
+                }
             }
         };
         const frame = (time)=>{
@@ -4792,10 +4852,8 @@ class Viewer extends EventEmitter {
     start() {
         if (this._active === false) {
             this._active = true;
-            requestAnimationFrame(()=>{
-                this.rotate();
-                this.resize();
-            });
+            this.rotate();
+            this.resize();
         }
         return this;
     }
@@ -4910,7 +4968,7 @@ class Viewer extends EventEmitter {
         this._taskManager.add(new Task(excute));
         return target;
     }
-    add(object, { node, args, scale, parent, position, rotation, manual, makeDefault, component, layerMask, ...props } = {}) {
+    add(object, { node, args, scale, parent, position, rotation, manual, makeDefault, component, layerMask, children, ...props } = {}) {
         let mount = false;
         let ins = getClassInstance(object, args);
         if (ins.isObject3D) {
@@ -4935,7 +4993,7 @@ class Viewer extends EventEmitter {
         if (parent === undefined) {
             parent = mount ? this._mount : this._scene;
         }
-        if (parent !== node && !node.parent) {
+        if (parent !== node) {
             parent.add(node);
         }
         if (component) {
@@ -4946,6 +5004,12 @@ class Viewer extends EventEmitter {
                 this._componentManager.addComponent(node, comp);
             }
         }
+        if (children) {
+            const children_ = Array.isArray(children) ? children : [
+                children
+            ];
+            node.add(...children_);
+        }
         if (layerMask) {
             node.layers.mask = layerMask;
         }
@@ -5158,7 +5222,7 @@ class Viewer extends EventEmitter {
         }, this._active = false, this._running = false, this._rootRotated = false, this._time = 0, this._lastTime = 0, this._lastFrameTime = 0, this._targetFrameRate = -1, this._fixedFrameTime = false, this._windowSize = ()=>[
                 window.innerWidth,
                 window.innerHeight
-            ], this._orientation = Orientation.AUTO;
+            ], this._orientation = Orientation.AUTO, this._freeze = false;
         const el = canvas || document.getElementById("canvas");
         const webgl = checkWebGL(el, webglOpts);
         if (!webgl) {
@@ -5295,8 +5359,6 @@ class MergeRefectPass {
             this._cubeMapMaterial = _getCubeMapMaterial();
             this._copyTexMaterial = _getClearMaterial();
             this._copyMesh = new Mesh(Viewer.fullscreenMesh.geometry, this._copyTexMaterial);
-            this._lodMeshes = this._lodPlanes.map((v)=>new Mesh(v, this._cubeMapMaterial));
-            this._sourceInit = false;
             return target;
         };
         pmremGenerator._fromCubeTexture = function(texture) {
@@ -5427,7 +5489,6 @@ class MergeMipBlurPass {
             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 Mesh(v, this._mipBlurMaterial));
             return target;
         };
         pmremGenerator._applyMipBlur = function(sourceTarget, texture, blurMinLod, blurMaxLod, sigma, exposure = 1) {
@@ -5628,7 +5689,7 @@ class BoxProjection extends Component {
             `);
         ShaderLib.physical.fragmentShader = ShaderLib.physical.fragmentShader.replace("varying vec3 vViewPosition;", `
             varying vec3 vViewPosition;
-            #if defined(USE_BOX_PROJECTION)
+            #if defined(USE_TRANSMISSION) || defined(USE_BOX_PROJECTION)
             varying vec3 vWorldPosition;
             #endif
             `);
@@ -5668,7 +5729,6 @@ class BoxProjection extends Component {
                 worldNormal = boxProjection(worldNormal, vWorldPosition, probePos.xyz, probeBoxMin.xyz, probeBoxMax.xyz);
             }
             #endif
-
             `);
     }
     useBoxProjection(shader) {
@@ -6508,6 +6568,9 @@ void main() {
 
     color.a *= u_opacity;
     gl_FragColor = color;
+
+    #include <tonemapping_fragment>
+	#include <colorspace_fragment>
 }
 `;
 class BMFontAtlas {
@@ -6589,13 +6652,13 @@ class BMFontAtlas {
                 value: 0.2
             },
             u_strokeColor: {
-                value: new Color(0xff0000)
+                value: new Color(0xffffff)
             },
             u_strokeWidth: {
                 value: 0
             },
             u_shadowColor: {
-                value: new Color(0xff0000)
+                value: new Color(0xffffff)
             },
             u_shadowBlur: {
                 value: 0
@@ -6623,5 +6686,5 @@ class BMFontAtlas {
     }
 }
 
-export { AccumulativeShadows, Animation, AnimationCurve, BINLoader, BMFontAtlas, BMFontTextGeometry, BMFontTextLayout, Box, BoxProjection, Center, Component, ContactShadows, DependentMode, DeviceInput, DropFile, EXRLoader, Easing, Environment, EventEmitter, FBXLoader, FInterpConstantTo, FInterpTo, FreelookVirtualCamera, GLTFLoader, HDRLoader, JSONLoader, KTX2Loader, Label, Loader, Logger, ObjectInstance, Orientation, PerformanceMonitor, Perlin, Plane, PropertyManager, QInterpConstantTo, QInterpTo, Quat_AngularDistance, Quat_Equals, Quat_exponentialDamp, Quat_quarticDamp, Quat_smoothDamp, RandomizedLight, Reflector, ReflectorMaterial, RenderTexture, Renderer, ResizeMode, ResourceManager, SVGLoader, ShadowMaterial, Sphere, SystemInfo, Task, TextureLoader, VInterpConstantTo, VInterpTo, Vec3_smoothDamp, Vector3_NEG_ONE, Vector3_ONE, Vector3_RIGHT, Vector3_UNIT_X, Vector3_UNIT_Y, Vector3_UNIT_Z, Vector3_UP, Vector3_ZERO, Viewer, applyProps, dependencies, exponentialDamp, find, frag_BoxfilterBlur, frag_cubeMapToPanorama, frag_panoramaToCubeMap, getChildByName, getChildren, getClassInstance, getShaderMaterial, mixin, property, quarticDamp, queryValues, smoothDamp, vert_fullscreen };
+export { AccumulativeShadows, Animation, AnimationCurve, BINLoader, BMFontAtlas, BMFontTextGeometry, BMFontTextLayout, Box, BoxProjection, Center, Component, ContactShadows, DependentMode, DeviceInput, DropFile, EXRLoader, Easing, Environment, EventEmitter, FBXLoader, FInterpConstantTo, FInterpTo, FreelookVirtualCamera, GLTFLoader, HDRLoader, JSONLoader, KTX2Loader, Label, Loader, Logger, ObjectInstance, Orientation, PerformanceMonitor, Perlin, Plane, PropertyManager, QInterpConstantTo, QInterpTo, Quat_AngularDistance, Quat_Equals, Quat_exponentialDamp, Quat_quarticDamp, Quat_smoothDamp, RandomizedLight, Reflector, ReflectorMaterial, RenderTexture, Renderer, ResizeMode, ResourceManager, SVGLoader, ShadowMaterial, Sphere, SystemInfo, Task, TextureLoader, VInterpConstantTo, VInterpTo, Vec3_smoothDamp, Vector3_NEG_ONE, Vector3_ONE, Vector3_RIGHT, Vector3_UNIT_X, Vector3_UNIT_Y, Vector3_UNIT_Z, Vector3_UP, Vector3_ZERO, Viewer, applyProps, dependencies, exponentialDamp, find, frag_BoxfilterBlur, frag_cubeMapToPanorama, frag_panoramaToCubeMap, getChildByName, getChildren, getClassInstance, getShaderMaterial, mixin, property, quarticDamp, queryValues, single, smoothDamp, vert_fullscreen };
 //# sourceMappingURL=module.js.map