three-base 2.0.19 → 2.0.21

package/ApngTexture.ts

@@ -86,6 +86,6 @@ export default class ApngTexture extends CanvasTexture {
 }
 
 // 定时更新时间戳
-threeUtils.addEventListener("requestAnimationFrame", (e) => {
+threeUtils.addEventListener("requestAnimationFrame", (e: any) => {
     ApngTexture.TimeTemp = e.timeTemp;
 });

package/ApngTextureManage.ts

@@ -18,7 +18,7 @@ class apngTextureManage {
         // 初始化定时更新时间戳
         if (apngTextureManage.isInit) {
             apngTextureManage.isInit = false;
-            threeUtils.addEventListener("requestAnimationFrame5000", (e) => {
+            threeUtils.addEventListener("requestAnimationFrame5000", (e: any) => {
                 apngTextureManage.TimeTemp = e.timeTemp;
             });
         }

package/ExtrudeMesh.ts

@@ -564,7 +564,7 @@ export default class ExtrudeMesh extends Mesh<BufferGeometry, Material> {
         this.geometry.dispose();
         this.geometry = geometry;
 
-        this.dispatchEvent({ type: "loaded" });
+        this.dispatchEvent({ type: "loaded" } as never);
     }
 
 

package/KeyFrameAnimation.ts

@@ -109,7 +109,7 @@ export default class KeyframeAnimation extends Object3D {
             (endKeyframe.rotation.z - startKeyframe.rotation.z) * progress + startKeyframe.rotation.z,
         );
 
-        this.dispatchEvent({ type: "update" });
+        this.dispatchEvent({ type: "update" } as never);
     }
 
     //更新关键帧的实例矩阵

package/Mirror.d.ts

@@ -0,0 +1,25 @@
+import { BufferGeometry, Camera, Group, Material, Matrix4, Mesh, PerspectiveCamera, Plane, PlaneGeometry, Scene, ShaderMaterial, Vector3, Vector4, WebGLRenderTarget, WebGLRenderer } from "three";
+export default class Mirror extends Mesh {
+    constructor(geometry?: BufferGeometry);
+    static geometry: PlaneGeometry;
+    isReflector: boolean;
+    type: string;
+    camera: PerspectiveCamera;
+    reflectorPlane: Plane;
+    normal: Vector3;
+    reflectorWorldPosition: Vector3;
+    cameraWorldPosition: Vector3;
+    rotationMatrix: Matrix4;
+    lookAtPosition: Vector3;
+    clipPlane: Vector4;
+    view: Vector3;
+    target: Vector3;
+    q: Vector4;
+    textureMatrix: Matrix4;
+    virtualCamera: PerspectiveCamera;
+    renderTarget: WebGLRenderTarget<import("three").Texture>;
+    material: ShaderMaterial;
+    onBeforeRender: (renderer: WebGLRenderer, scene: Scene, camera: Camera, geometry: BufferGeometry, material: Material, group: Group) => void;
+    getRenderTarget(): WebGLRenderTarget<import("three").Texture>;
+    dispose(): void;
+}

package/Mirror.js

@@ -0,0 +1,197 @@
+/*
+ * @Author: xiaosihan
+ * @Date: 2023-08-04 17:17:15
+ * @Last Modified by: xiaosihan
+ * @Last Modified time: 2023-08-04 20:54:29
+ */
+import { Color, DoubleSide, HalfFloatType, Matrix4, Mesh, PerspectiveCamera, Plane, PlaneGeometry, ShaderMaterial, Vector3, Vector4, WebGLRenderTarget } from "three";
+// 镜子模型
+export default class Mirror extends Mesh {
+    constructor(geometry = Mirror.geometry) {
+        super(geometry);
+    }
+    // 正方形网格
+    static geometry = (() => {
+        const geometry = new PlaneGeometry(10, 10, 1, 1);
+        return geometry;
+    })();
+    isReflector = true;
+    type = 'Reflector';
+    camera = new PerspectiveCamera();
+    reflectorPlane = new Plane();
+    normal = new Vector3();
+    reflectorWorldPosition = new Vector3();
+    cameraWorldPosition = new Vector3();
+    rotationMatrix = new Matrix4();
+    lookAtPosition = new Vector3(0, 0, -1);
+    clipPlane = new Vector4();
+    view = new Vector3();
+    target = new Vector3();
+    q = new Vector4();
+    textureMatrix = new Matrix4();
+    virtualCamera = this.camera;
+    renderTarget = new WebGLRenderTarget(2048, 2048, { samples: 0, type: HalfFloatType });
+    material = new ShaderMaterial({
+        uniforms: {
+            'color': {
+                value: new Color("#b6b6b6")
+            },
+            'tDiffuse': {
+                value: this.renderTarget.texture
+            },
+            'textureMatrix': {
+                value: this.textureMatrix
+            },
+            blurAmount: {
+                value: 0.5
+            } // 模糊程度，可以根据需求调整
+        },
+        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;
+            uniform float blurAmount;
+
+            #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>
+
+                vec2 texelSize = 1.0 / vec2(1024,1024);
+                vec4 fragColor = vec4(0.0);
+            
+                  for (float offsetX = -blurAmount; offsetX <= blurAmount; offsetX += texelSize.x) {
+                    for (float offsetY = -blurAmount; offsetY <= blurAmount; offsetY += texelSize.y) {
+                        //  fragColor += texture2DProj(tDiffuse, vUv + vec4(offsetX, offsetY, 0.0, 0.0) * texelSize);
+                         fragColor += texture2DProj(tDiffuse, vUv + vec4(offsetX * texelSize.x, offsetY * texelSize.y, 0.0, 0.0) );
+                    }
+                  }
+            
+                // fragColor /= pow(2.0 * blurAmount + 1.0, 2.0);
+                // gl_FragColor = color;
+
+                fragColor = texture2DProj( tDiffuse, vUv );
+                gl_FragColor = vec4( blendOverlay( fragColor.rgb, color ), 1.0 );
+
+                #include <tonemapping_fragment>
+                #include <colorspace_fragment>
+            }`,
+        depthTest: true,
+        depthWrite: true,
+        transparent: true,
+        side: DoubleSide
+    });
+    onBeforeRender = (renderer, scene, camera, geometry, material, group) => {
+        this.reflectorWorldPosition.setFromMatrixPosition(this.matrixWorld);
+        this.cameraWorldPosition.setFromMatrixPosition(camera.matrixWorld);
+        this.rotationMatrix.extractRotation(this.matrixWorld);
+        this.normal.set(0, 0, 1);
+        this.normal.applyMatrix4(this.rotationMatrix);
+        this.view.subVectors(this.reflectorWorldPosition, this.cameraWorldPosition);
+        // Avoid rendering when reflector is facing away
+        if (this.view.dot(this.normal) > 0) {
+            this.normal.set(0, 0, -1);
+        }
+        ;
+        this.view.reflect(this.normal).negate();
+        this.view.add(this.reflectorWorldPosition);
+        this.rotationMatrix.extractRotation(camera.matrixWorld);
+        this.lookAtPosition.set(0, 0, -1);
+        this.lookAtPosition.applyMatrix4(this.rotationMatrix);
+        this.lookAtPosition.add(this.cameraWorldPosition);
+        this.target.subVectors(this.reflectorWorldPosition, this.lookAtPosition);
+        this.target.reflect(this.normal).negate();
+        this.target.add(this.reflectorWorldPosition);
+        this.virtualCamera.position.copy(this.view);
+        this.virtualCamera.up.set(0, 1, 0);
+        this.virtualCamera.up.applyMatrix4(this.rotationMatrix);
+        this.virtualCamera.up.reflect(this.normal);
+        this.virtualCamera.lookAt(this.target);
+        this.virtualCamera.far = this.camera.far; // Used in WebGLBackground
+        this.virtualCamera.updateMatrixWorld();
+        this.virtualCamera.projectionMatrix.copy(camera.projectionMatrix);
+        // Update the texture matrix
+        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(this.virtualCamera.projectionMatrix);
+        this.textureMatrix.multiply(this.virtualCamera.matrixWorldInverse);
+        this.textureMatrix.multiply(this.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
+        this.reflectorPlane.setFromNormalAndCoplanarPoint(this.normal, this.reflectorWorldPosition);
+        this.reflectorPlane.applyMatrix4(this.virtualCamera.matrixWorldInverse);
+        this.clipPlane.set(this.reflectorPlane.normal.x, this.reflectorPlane.normal.y, this.reflectorPlane.normal.z, this.reflectorPlane.constant);
+        const projectionMatrix = this.virtualCamera.projectionMatrix;
+        this.q.x = (Math.sign(this.clipPlane.x) + projectionMatrix.elements[8]) / projectionMatrix.elements[0];
+        this.q.y = (Math.sign(this.clipPlane.y) + projectionMatrix.elements[9]) / projectionMatrix.elements[5];
+        this.q.z = -1.0;
+        this.q.w = (1.0 + projectionMatrix.elements[10]) / projectionMatrix.elements[14];
+        // Calculate the scaled plane vector
+        this.clipPlane.multiplyScalar(2.0 / this.clipPlane.dot(this.q));
+        // Replacing the third row of the projection matrix
+        projectionMatrix.elements[2] = this.clipPlane.x;
+        projectionMatrix.elements[6] = this.clipPlane.y;
+        projectionMatrix.elements[10] = this.clipPlane.z + 1.0 - 0.003;
+        projectionMatrix.elements[14] = this.clipPlane.w;
+        // Render
+        this.visible = false;
+        const currentRenderTarget = renderer.getRenderTarget();
+        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(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, this.virtualCamera);
+        renderer.xr.enabled = currentXrEnabled;
+        renderer.shadowMap.autoUpdate = currentShadowAutoUpdate;
+        renderer.setRenderTarget(currentRenderTarget);
+        // Restore viewport
+        //@ts-ignore
+        const viewport = this.camera.viewport;
+        if (viewport !== undefined) {
+            debugger;
+            renderer.state.viewport(viewport);
+        }
+        this.visible = true;
+    };
+    getRenderTarget() {
+        return this.renderTarget;
+    }
+    ;
+    dispose() {
+        this.renderTarget.dispose();
+        // this.material.dispose();
+    }
+    ;
+}

package/Mirror.ts

@@ -0,0 +1,255 @@
+/*
+ * @Author: xiaosihan 
+ * @Date: 2023-08-04 17:17:15 
+ * @Last Modified by: xiaosihan
+ * @Last Modified time: 2023-08-04 20:54:29
+ */
+
+import { BufferGeometry, Camera, Color, DoubleSide, Group, HalfFloatType, Material, Matrix4, Mesh, PerspectiveCamera, Plane, PlaneGeometry, Scene, ShaderMaterial, Vector3, Vector4, WebGLRenderTarget, WebGLRenderer } from "three";
+
+
+// 镜子模型
+export default class Mirror extends Mesh {
+
+    constructor(geometry: BufferGeometry = Mirror.geometry) {
+        super(geometry);
+    }
+
+    // 正方形网格
+    static geometry = (() => {
+        const geometry = new PlaneGeometry(10, 10, 1, 1);
+        return geometry;
+    })();
+
+    isReflector = true;
+
+    type = 'Reflector';
+
+    camera = new PerspectiveCamera();
+
+    reflectorPlane = new Plane();
+    normal = new Vector3();
+    reflectorWorldPosition = new Vector3();
+    cameraWorldPosition = new Vector3();
+    rotationMatrix = new Matrix4();
+    lookAtPosition = new Vector3(0, 0, - 1);
+    clipPlane = new Vector4();
+
+    view = new Vector3();
+    target = new Vector3();
+    q = new Vector4();
+
+    textureMatrix = new Matrix4();
+    virtualCamera = this.camera;
+
+    renderTarget = new WebGLRenderTarget(2048, 2048, { samples: 0, type: HalfFloatType });
+
+    material = new ShaderMaterial({
+        uniforms: {
+            'color': {
+                value: new Color("#b6b6b6")
+            },
+
+            'tDiffuse': {
+                value: this.renderTarget.texture
+            },
+
+            'textureMatrix': {
+                value: this.textureMatrix
+            },
+            blurAmount: {
+                value: 0.5
+            } // 模糊程度，可以根据需求调整
+
+        },
+
+        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;
+            uniform float blurAmount;
+
+            #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>
+
+                vec2 texelSize = 1.0 / vec2(1024,1024);
+                vec4 fragColor = vec4(0.0);
+            
+                  for (float offsetX = -blurAmount; offsetX <= blurAmount; offsetX += texelSize.x) {
+                    for (float offsetY = -blurAmount; offsetY <= blurAmount; offsetY += texelSize.y) {
+                        //  fragColor += texture2DProj(tDiffuse, vUv + vec4(offsetX, offsetY, 0.0, 0.0) * texelSize);
+                         fragColor += texture2DProj(tDiffuse, vUv + vec4(offsetX * texelSize.x, offsetY * texelSize.y, 0.0, 0.0) );
+                    }
+                  }
+            
+                // fragColor /= pow(2.0 * blurAmount + 1.0, 2.0);
+                // gl_FragColor = color;
+
+                fragColor = texture2DProj( tDiffuse, vUv );
+                gl_FragColor = vec4( blendOverlay( fragColor.rgb, color ), 1.0 );
+
+                #include <tonemapping_fragment>
+                #include <colorspace_fragment>
+            }`,
+        depthTest: true,
+        depthWrite: true,
+        transparent: true,
+        side: DoubleSide
+    });
+
+
+    onBeforeRender = (renderer: WebGLRenderer, scene: Scene, camera: Camera, geometry: BufferGeometry, material: Material, group: Group) => {
+
+        this.reflectorWorldPosition.setFromMatrixPosition(this.matrixWorld);
+        this.cameraWorldPosition.setFromMatrixPosition(camera.matrixWorld);
+
+        this.rotationMatrix.extractRotation(this.matrixWorld);
+
+        this.normal.set(0, 0, 1);
+        this.normal.applyMatrix4(this.rotationMatrix);
+
+        this.view.subVectors(this.reflectorWorldPosition, this.cameraWorldPosition);
+
+        // Avoid rendering when reflector is facing away
+
+        if (this.view.dot(this.normal) > 0) {
+            this.normal.set(0, 0, -1);
+        };
+
+        this.view.reflect(this.normal).negate();
+        this.view.add(this.reflectorWorldPosition);
+
+        this.rotationMatrix.extractRotation(camera.matrixWorld);
+
+        this.lookAtPosition.set(0, 0, - 1);
+        this.lookAtPosition.applyMatrix4(this.rotationMatrix);
+        this.lookAtPosition.add(this.cameraWorldPosition);
+
+        this.target.subVectors(this.reflectorWorldPosition, this.lookAtPosition);
+        this.target.reflect(this.normal).negate();
+        this.target.add(this.reflectorWorldPosition);
+
+        this.virtualCamera.position.copy(this.view);
+        this.virtualCamera.up.set(0, 1, 0);
+        this.virtualCamera.up.applyMatrix4(this.rotationMatrix);
+        this.virtualCamera.up.reflect(this.normal);
+        this.virtualCamera.lookAt(this.target);
+
+        this.virtualCamera.far = this.camera.far; // Used in WebGLBackground
+
+        this.virtualCamera.updateMatrixWorld();
+        this.virtualCamera.projectionMatrix.copy(camera.projectionMatrix);
+
+        // Update the texture matrix
+        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(this.virtualCamera.projectionMatrix);
+        this.textureMatrix.multiply(this.virtualCamera.matrixWorldInverse);
+        this.textureMatrix.multiply(this.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
+        this.reflectorPlane.setFromNormalAndCoplanarPoint(this.normal, this.reflectorWorldPosition);
+        this.reflectorPlane.applyMatrix4(this.virtualCamera.matrixWorldInverse);
+
+        this.clipPlane.set(this.reflectorPlane.normal.x, this.reflectorPlane.normal.y, this.reflectorPlane.normal.z, this.reflectorPlane.constant);
+
+        const projectionMatrix = this.virtualCamera.projectionMatrix;
+
+        this.q.x = (Math.sign(this.clipPlane.x) + projectionMatrix.elements[8]) / projectionMatrix.elements[0];
+        this.q.y = (Math.sign(this.clipPlane.y) + projectionMatrix.elements[9]) / projectionMatrix.elements[5];
+        this.q.z = - 1.0;
+        this.q.w = (1.0 + projectionMatrix.elements[10]) / projectionMatrix.elements[14];
+
+        // Calculate the scaled plane vector
+        this.clipPlane.multiplyScalar(2.0 / this.clipPlane.dot(this.q));
+
+        // Replacing the third row of the projection matrix
+        projectionMatrix.elements[2] = this.clipPlane.x;
+        projectionMatrix.elements[6] = this.clipPlane.y;
+        projectionMatrix.elements[10] = this.clipPlane.z + 1.0 - 0.003;
+        projectionMatrix.elements[14] = this.clipPlane.w;
+
+        // Render
+        this.visible = false;
+
+        const currentRenderTarget = renderer.getRenderTarget();
+
+        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(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, this.virtualCamera);
+
+        renderer.xr.enabled = currentXrEnabled;
+        renderer.shadowMap.autoUpdate = currentShadowAutoUpdate;
+
+        renderer.setRenderTarget(currentRenderTarget);
+
+        // Restore viewport
+        //@ts-ignore
+        const viewport = this.camera.viewport;
+        if (viewport !== undefined) {
+            debugger;
+            renderer.state.viewport(viewport);
+        }
+
+        this.visible = true;
+
+    }
+
+    getRenderTarget() {
+
+        return this.renderTarget;
+
+    };
+
+    dispose() {
+        this.renderTarget.dispose();
+        // this.material.dispose();
+    };
+
+}

package/PlaneModal1/PlaneModal1.d.ts

@@ -16,7 +16,7 @@ export default class PlaneModal1 extends Mesh {
     static img: HTMLImageElement;
     canvas: HTMLCanvasElement;
     context: CanvasRenderingContext2D;
-    texture: import("three").CanvasTexture | import("three").Texture;
+    texture: import("three").Texture;
     _config: {
         size: number;
         title: string;

package/PlaneModal1/PlaneModal1.ts

@@ -144,7 +144,7 @@ export default class PlaneModal1 extends Mesh {
 
         this.texture.needsUpdate = true;
 
-        this.dispatchEvent({ type: "loaded" });
+        this.dispatchEvent({ type: "loaded" } as never);
     }
 
 

package/PlaneText.d.ts

@@ -22,16 +22,23 @@ export default class PlaneText extends Mesh {
     spriteText: SpriteText;
     material: MeshBasicMaterial;
     set(parame: Props): void;
-    get(prop: keyof SpriteText): string | number | boolean | ((event: import("three").Event) => void) | Vector3 | import("three").Object3D<import("three").Event> | import("three").BufferGeometry<import("three").NormalBufferAttributes> | ((force?: boolean) => void) | import("three").Object3D<import("three").Event>[] | HTMLCanvasElement | import("three").Vector2 | import("three").Material | import("three").Matrix4 | import("three").Quaternion | import("three").Euler | ((callback: (object: import("three").Object3D<import("three").Event>) => any) => void) | import("three").Matrix3 | import("three").Layers | import("three").AnimationClip[] | {
-        [key: string]: any;
-    } | ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, material: import("three").Material, group: import("three").Group) => void) | ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, material: import("three").Material, group: import("three").Group) => void) | ((matrix: import("three").Matrix4) => void) | ((axis: Vector3, angle: number) => void) | ((euler: import("three").Euler) => void) | ((m: import("three").Matrix4) => void) | ((q: import("three").Quaternion) => void) | ((vector: Vector3) => Vector3) | ((vector: Vector3) => Vector3) | {
+    get(prop: keyof SpriteText): string | number | boolean | Vector3 | import("three").Object3D<import("three").Object3DEventMap> | import("three").BufferGeometry<import("three").NormalBufferAttributes> | ((force?: boolean) => void) | import("three").Object3D<import("three").Object3DEventMap>[] | HTMLCanvasElement | import("three").Vector2 | import("three").Material | Record<string, any> | import("three").Matrix4 | import("three").Quaternion | (<T extends keyof import("three").Object3DEventMap>(event: import("three").BaseEvent<T> & import("three").Object3DEventMap[T]) => void) | import("three").Euler | ((callback: (object: import("three").Object3D<import("three").Object3DEventMap>) => any) => void) | import("three").Matrix3 | import("three").Layers | import("three").AnimationClip[] | ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, shadowCamera: import("three").Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, depthMaterial: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void) | ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, shadowCamera: import("three").Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, depthMaterial: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void) | ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, material: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void) | ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, material: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void) | ((matrix: import("three").Matrix4) => void) | ((axis: Vector3, angle: number) => void) | ((euler: import("three").Euler) => void) | ((m: import("three").Matrix4) => void) | ((q: import("three").Quaternion) => void) | ((vector: Vector3) => Vector3) | ((vector: Vector3) => Vector3) | {
         (vector: Vector3): void;
         (x: number, y: number, z: number): void;
-    } | ((id: number) => import("three").Object3D<import("three").Event>) | ((name: string) => import("three").Object3D<import("three").Event>) | ((name: string, value: any) => import("three").Object3D<import("three").Event>) | ((name: string, value: any) => import("three").Object3D<import("three").Event>[]) | ((target: Vector3) => Vector3) | ((target: import("three").Quaternion) => import("three").Quaternion) | ((target: Vector3) => Vector3) | ((target: Vector3) => Vector3) | ((raycaster: import("three").Raycaster, intersects: import("three").Intersection<import("three").Object3D<import("three").Event>>[]) => void) | ((callback: (object: import("three").Object3D<import("three").Event>) => any) => void) | ((callback: (object: import("three").Object3D<import("three").Event>) => any) => void) | (() => void) | ((updateParents: boolean, updateChildren: boolean) => void) | ((meta?: {
+    } | ((id: number) => import("three").Object3D<import("three").Object3DEventMap>) | ((name: string) => import("three").Object3D<import("three").Object3DEventMap>) | ((name: string, value: any) => import("three").Object3D<import("three").Object3DEventMap>) | ((name: string, value: any, optionalTarget?: import("three").Object3D<import("three").Object3DEventMap>[]) => import("three").Object3D<import("three").Object3DEventMap>[]) | ((target: Vector3) => Vector3) | ((target: import("three").Quaternion) => import("three").Quaternion) | ((target: Vector3) => Vector3) | ((target: Vector3) => Vector3) | ((raycaster: import("three").Raycaster, intersects: import("three").Intersection<import("three").Object3D<import("three").Object3DEventMap>>[]) => void) | ((callback: (object: import("three").Object3D<import("three").Object3DEventMap>) => any) => void) | ((callback: (object: import("three").Object3D<import("three").Object3DEventMap>) => any) => void) | (() => void) | ((updateParents: boolean, updateChildren: boolean) => void) | ((meta?: {
         geometries: any;
         materials: any;
         textures: any;
         images: any;
-    }) => any) | import("three").SpriteMaterial | ((source: SpriteText, recursive?: boolean) => SpriteText) | (() => void) | ((quaternion: import("three").Quaternion) => SpriteText) | ((axis: Vector3, angle: number) => SpriteText) | ((axis: Vector3, angle: number) => SpriteText) | ((angle: number) => SpriteText) | ((angle: number) => SpriteText) | ((angle: number) => SpriteText) | ((axis: Vector3, distance: number) => SpriteText) | ((distance: number) => SpriteText) | ((distance: number) => SpriteText) | ((distance: number) => SpriteText) | ((...object: import("three").Object3D<import("three").Event>[]) => SpriteText) | ((...object: import("three").Object3D<import("three").Event>[]) => SpriteText) | (() => SpriteText) | (() => SpriteText) | ((object: import("three").Object3D<import("three").Event>) => SpriteText) | ((recursive?: boolean) => SpriteText) | (<T extends string>(type: T, listener: import("three").EventListener<import("three").Event, T, SpriteText>) => void) | (<T_1 extends string>(type: T_1, listener: import("three").EventListener<import("three").Event, T_1, SpriteText>) => boolean) | (<T_2 extends string>(type: T_2, listener: import("three").EventListener<import("three").Event, T_2, SpriteText>) => void);
+    }) => any) | import("three").SpriteMaterial | ((source: SpriteText, recursive?: boolean) => SpriteText) | (() => void) | ((quaternion: import("three").Quaternion) => SpriteText) | ((axis: Vector3, angle: number) => SpriteText) | ((axis: Vector3, angle: number) => SpriteText) | ((angle: number) => SpriteText) | ((angle: number) => SpriteText) | ((angle: number) => SpriteText) | ((axis: Vector3, distance: number) => SpriteText) | ((distance: number) => SpriteText) | ((distance: number) => SpriteText) | ((distance: number) => SpriteText) | ((...object: import("three").Object3D<import("three").Object3DEventMap>[]) => SpriteText) | ((...object: import("three").Object3D<import("three").Object3DEventMap>[]) => SpriteText) | (() => SpriteText) | (() => SpriteText) | ((object: import("three").Object3D<import("three").Object3DEventMap>) => SpriteText) | ((recursive?: boolean) => SpriteText) | {
+        <T_1 extends keyof import("three").Object3DEventMap>(type: T_1, listener: import("three").EventListener<import("three").Object3DEventMap[T_1], T_1, SpriteText>): void;
+        <T_2 extends string>(type: T_2, listener: import("three").EventListener<{}, T_2, SpriteText>): void;
+    } | {
+        <T_3 extends keyof import("three").Object3DEventMap>(type: T_3, listener: import("three").EventListener<import("three").Object3DEventMap[T_3], T_3, SpriteText>): boolean;
+        <T_4 extends string>(type: T_4, listener: import("three").EventListener<{}, T_4, SpriteText>): boolean;
+    } | {
+        <T_5 extends keyof import("three").Object3DEventMap>(type: T_5, listener: import("three").EventListener<import("three").Object3DEventMap[T_5], T_5, SpriteText>): void;
+        <T_6 extends string>(type: T_6, listener: import("three").EventListener<{}, T_6, SpriteText>): void;
+    };
 }
 export {};

package/PlaneWithHtml.ts

@@ -78,7 +78,7 @@ export default class PlaneWithHtml extends Mesh {
 
         });
 
-        this.dispatchEvent({ type: "loaded" });
+        this.dispatchEvent({ type: "loaded" } as never);
     }
 
 

package/SpriteModal1/SpriteModal1.d.ts

@@ -1,4 +1,4 @@
-import { Sprite, CanvasTexture, Raycaster, Intersection } from "three";
+import { Sprite, Raycaster, Intersection } from "three";
 export type SpritModal1Config = {
     size?: number;
     title?: string;
@@ -14,7 +14,7 @@ export default class SpritModal1 extends Sprite {
     static img: HTMLImageElement;
     canvas: HTMLCanvasElement;
     context: CanvasRenderingContext2D;
-    texture: CanvasTexture | import("three").Texture;
+    texture: import("three").Texture;
     _config: {
         size: number;
         title: string;

package/SpriteModal1/SpriteModal1.ts

@@ -141,7 +141,7 @@ export default class SpritModal1 extends Sprite {
 
         this.texture.needsUpdate = true;
 
-        this.dispatchEvent({ type: "loaded" });
+        this.dispatchEvent({ type: "loaded" } as never);
     }
 
     //鼠标拾取计算

package/SpriteWithHtml.ts

@@ -55,7 +55,7 @@ export default class SpriteWithHtml extends Sprite {
 
         });
 
-        this.dispatchEvent({ type: "loaded" });
+        this.dispatchEvent({ type: "loaded" } as never);
     }
 
 

package/Text3D/Text3D.ts

@@ -81,7 +81,7 @@ export default class Text3D extends Mesh {
                         bevelSegments: this._config.bevelSegments,//斜角分段
                     });
                     this.geometry.center();
-                    this.dispatchEvent({ type: "loaded" });
+                    this.dispatchEvent({ type: "loaded" } as never);
                 }
             })
 

package/ThreeBase.d.ts

@@ -16,7 +16,6 @@ export default class ThreeBase extends EventDispatcher {
     scene: Scene;
     threeMouse: ThreeMouse;
     controls: OrbitControls;
-    isRendererContextLost: boolean;
     setContainer(div: HTMLDivElement | null): Promise<void>;
     setSize(width: number, height: number): void;
     controlsDistance: Transition;