three-base 2.0.41 → 2.0.43

package/{InstancedGroupMesh.d.ts → InstancedMeshBase.d.ts}

@@ -1,13 +1,21 @@
-import { Color, Group, InstancedMesh, Matrix4, Mesh } from 'three';
-export default class InstancedGroupMesh extends Mesh {
-    children: InstancedMesh[];
+import { Color, InstancedBufferAttribute, InstancedMesh, Matrix4, Mesh, Vector3 } from "three";
+import MeshBase from "./MeshBase";
+export default class InstancedMeshBase extends MeshBase {
+    constructor(url?: string);
+    url: string;
     isInstancedGroupMesh: boolean;
     count: number;
+    size: Vector3;
     meshCollect: Record<string, Mesh[]>;
     instanceCollect: Record<string, InstancedMesh>;
+    colorMap: Map<String, Color>;
+    children: InstancedMesh[];
     static matrix: Matrix4;
-    constructor(group: Group, count: number);
+    instanceMatrix: InstancedBufferAttribute;
+    instanceColor: InstancedBufferAttribute;
+    loadModel(url: string): Promise<void>;
     computeBoundingSphere: import("lodash").DebouncedFunc<() => void>;
+    setCount(count?: number): void;
     setMatrixAt(index: number, matrix: Matrix4): void;
     setColorAt(index: number, color: (instancedMesh: InstancedMesh) => Color | undefined): void;
     updateMatrixWorld(force?: boolean): void;

package/InstancedMeshBase.js

@@ -0,0 +1,205 @@
+/*
+ * @Author: xiaosihan
+ * @Date: 2024-02-05 09:31:57
+ * @Last Modified by: xiaosihan
+ * @Last Modified time: 2024-02-05 09:40:12
+ */
+import { throttle } from "lodash";
+import { InstancedBufferAttribute, InstancedMesh, Matrix4, Object3D, Vector3 } from "three";
+import MeshBase from "./MeshBase";
+import threeUtils from "./threeUtils";
+import threeLoader from "./threeLoader";
+// 实例模型组对象
+export default class InstancedMeshBase extends MeshBase {
+    constructor(url) {
+        super(url);
+    }
+    url = "";
+    isInstancedGroupMesh = true;
+    count = 0;
+    size = new Vector3(1, 1, 1);
+    meshCollect = {};
+    instanceCollect = {};
+    colorMap = new Map();
+    static matrix = new Matrix4();
+    instanceMatrix = new InstancedBufferAttribute(new Float32Array(0 * 16), 16);
+    instanceColor = new InstancedBufferAttribute(new Float32Array(0 * 3), 3);
+    // 重构加载模型的方法
+    async loadModel(url) {
+        if (!url) {
+            this.clear();
+            return;
+        }
+        this.loaded = false;
+        // 没有模型并且没有加载任务时就去加载模型
+        if (!MeshBase.models.get(url) && !MeshBase.loadModeling.get(url)) {
+            MeshBase.loadModeling.set(url, true);
+            let modal = new Object3D();
+            if (/\.fbx$/i.test(url)) {
+                await threeLoader.fbxLoader.loadAsync(url).then(res => {
+                    modal = res;
+                }).catch(() => {
+                    console.error(`${url},加载失败`);
+                });
+            }
+            else if (/\.(gltf|glb)$/i.test(url)) {
+                await threeLoader.gltfLoader.loadAsync(url).then(res => {
+                    modal = res.scene;
+                    modal.animations = res.animations;
+                }).catch(() => {
+                    console.error(`${url},加载失败`);
+                });
+            }
+            else {
+                console.error(`${url},不支持的格式`);
+            }
+            threeUtils.center(modal);
+            threeUtils.alignBottom(modal);
+            modal.updateMatrixWorld(true);
+            MeshBase.models.set(url, modal);
+            MeshBase.loadModeling.set(url, false);
+        }
+        // 如果模型还在加载中, 就等待模型加载完成
+        do {
+            await new Promise(resolve => setTimeout(resolve, 50));
+        } while (MeshBase.loadModeling.get(url));
+        if (MeshBase.models.get(url)) {
+            this.clear();
+            const mesh = MeshBase.models.get(url);
+            // // 判断是否有动画
+            // this.hasAnimation = mesh.animations.length > 0;
+            // if (this.hasAnimation) {
+            //     const model = SkeletonUtils.clone(mesh);
+            //     this.mixer = new AnimationMixer(model);
+            //     this.animationActions = {};
+            //     mesh.animations.map(animation => {
+            //         const animationAction = this.mixer!.clipAction(animation).play();
+            //         animationAction.weight = 0;
+            //         this.animationActions[animation.name] = animationAction;
+            //     });
+            //     this.add(model);
+            // } else {
+            //     this.add(mesh.clone(true));
+            // }
+            this.size.copy(threeUtils.getSize(mesh));
+            const { meshCollect, instanceCollect } = this;
+            mesh.updateMatrixWorld(true);
+            // collect all mesh counts, in case there are more than one copy of the same mesh in this group
+            mesh.traverse((obj) => {
+                const mesh = obj;
+                if (mesh.isMesh) {
+                    mesh.matrixWorld.decompose(mesh.position, mesh.quaternion, mesh.scale);
+                    mesh.rotation.setFromQuaternion(mesh.quaternion);
+                    mesh.updateMatrix();
+                    // same geometry and same material consider as the same mesh
+                    const uuid = mesh.geometry.uuid + '/' + mesh.material.uuid;
+                    if (meshCollect[uuid]) {
+                        meshCollect[uuid].push(mesh);
+                    }
+                    else {
+                        meshCollect[uuid] = [mesh];
+                    }
+                }
+                else {
+                    obj.position.set(0, 0, 0);
+                    obj.scale.set(1, 1, 1);
+                    obj.rotation.set(0, 0, 0);
+                }
+            });
+            // create all instances
+            Object.keys(meshCollect).forEach(uuid => {
+                const meshes = meshCollect[uuid];
+                const mesh = meshes[0];
+                const instancedMesh = new InstancedMesh(mesh.geometry, mesh.material, meshes.length * this.count);
+                instancedMesh.name = mesh.name;
+                instancedMesh.frustumCulled = false;
+                instanceCollect[uuid] = instancedMesh;
+                this.add(instancedMesh);
+            });
+            // 加载完成事件
+            await new Promise(resolve => setTimeout(resolve, 100));
+            // 加载完成事件
+            this.dispatchEvent({ type: "loaded" });
+            this.loaded = true;
+        }
+    }
+    // 更新包围盒
+    computeBoundingSphere = throttle(() => {
+        this.traverse(m => {
+            m.computeBoundingSphere();
+        });
+    }, 1000);
+    //初始实例矩阵的数量
+    setCount(count = 0) {
+        const instanceMatrix = new InstancedBufferAttribute(new Float32Array(count * 16), 16);
+        const instanceColor = new InstancedBufferAttribute(new Float32Array(count * 3).fill(1), 3);
+        for (let i = 0; i < this.count; i++) {
+            instanceMatrix.copyAt(i, this.instanceMatrix, i);
+            instanceColor.copyAt(i, this.instanceColor, i);
+        }
+        this.instanceMatrix = instanceMatrix;
+        this.instanceColor = instanceColor;
+        this.count = count;
+        this.children.map((instanceMesh) => {
+            const instanceMatrix = new InstancedBufferAttribute(new Float32Array(count * 16), 16);
+            const instanceColor = new InstancedBufferAttribute(new Float32Array(count * 3).fill(1), 3);
+            for (let i = 0; i < instanceMesh.count; i++) {
+                instanceMatrix.copyAt(i, this.instanceMatrix, i);
+                instanceColor.copyAt(i, this.instanceColor, i);
+            }
+            instanceMesh.instanceMatrix = instanceMatrix;
+            instanceMesh.instanceColor = instanceColor;
+            instanceMesh.count = count;
+        });
+    }
+    // 设置矩阵
+    setMatrixAt(index, matrix) {
+        Object.keys(this.meshCollect).forEach(uuid => {
+            const instancedMesh = this.instanceCollect[uuid];
+            const collect = this.meshCollect[uuid];
+            collect.forEach((mesh, i) => {
+                InstancedMeshBase.matrix.copy(mesh.matrix);
+                InstancedMeshBase.matrix.premultiply(matrix);
+                instancedMesh.setMatrixAt(collect.length * index + i, InstancedMeshBase.matrix);
+                instancedMesh.instanceMatrix.needsUpdate = true;
+            });
+        });
+        this.computeBoundingSphere();
+    }
+    // 设置颜色
+    setColorAt(index, color) {
+        Object.keys(this.meshCollect).forEach(uuid => {
+            const instancedMesh = this.instanceCollect[uuid];
+            const collect = this.meshCollect[uuid];
+            collect.forEach((mesh, i) => {
+                const c = color(instancedMesh);
+                if (c) {
+                    instancedMesh.setColorAt(collect.length * index + i, c);
+                    instancedMesh.instanceColor.needsUpdate = true;
+                }
+            });
+        });
+    }
+    // 同步属性
+    updateMatrixWorld(force) {
+        super.updateMatrixWorld(force);
+        const { cursor, enableEvent } = this.userData;
+        this.traverse(obj => {
+            Object.assign(obj.userData, { cursor, enableEvent });
+        });
+    }
+    // 事件监听
+    addEventListener(name, callback) {
+        super.addEventListener(name, callback);
+        this.children.map(mesh => {
+            mesh.addEventListener(name, callback);
+        });
+    }
+    // 取消事件的监听
+    removeEventListener(name, callback) {
+        super.removeEventListener(name, callback);
+        this.children.map(mesh => {
+            mesh.removeEventListener(name, callback);
+        });
+    }
+}

package/InstancedMeshBase.ts

@@ -0,0 +1,259 @@
+/*
+ * @Author: xiaosihan 
+ * @Date: 2024-02-05 09:31:57 
+ * @Last Modified by: xiaosihan
+ * @Last Modified time: 2024-02-05 09:40:12
+ */
+
+import { throttle } from "lodash";
+import { Color, InstancedBufferAttribute, InstancedMesh, Material, Matrix4, Mesh, Object3D, Vector3 } from "three";
+import MeshBase from "./MeshBase";
+import threeUtils from "./threeUtils";
+import threeLoader from "./threeLoader";
+
+// 实例模型组对象
+export default class InstancedMeshBase extends MeshBase {
+    constructor(url?: string) {
+        super(url);
+    }
+
+    url = "";
+
+    isInstancedGroupMesh = true
+
+    count: number = 0;
+
+    size = new Vector3(1, 1, 1);
+
+    meshCollect: Record<string, Mesh[]> = {}
+
+    instanceCollect: Record<string, InstancedMesh> = {}
+
+    colorMap = new Map<String, Color>();
+
+    declare children: InstancedMesh[];
+
+    static matrix = new Matrix4()
+
+    instanceMatrix = new InstancedBufferAttribute(new Float32Array(0 * 16), 16);
+
+    instanceColor = new InstancedBufferAttribute(new Float32Array(0 * 3), 3);
+
+    // 重构加载模型的方法
+    async loadModel(url: string) {
+        if (!url) {
+            this.clear();
+            return;
+        }
+
+        this.loaded = false;
+
+        // 没有模型并且没有加载任务时就去加载模型
+        if (!MeshBase.models.get(url) && !MeshBase.loadModeling.get(url)) {
+            MeshBase.loadModeling.set(url, true);
+
+            let modal = new Object3D();
+
+            if (/\.fbx$/i.test(url)) {
+                await threeLoader.fbxLoader.loadAsync(url).then(res => {
+                    modal = res;
+                }).catch(() => {
+                    console.error(`${url},加载失败`);
+                })
+            } else if (/\.(gltf|glb)$/i.test(url)) {
+                await threeLoader.gltfLoader.loadAsync(url).then(res => {
+                    modal = res.scene;
+                    modal.animations = res.animations;
+                }).catch(() => {
+                    console.error(`${url},加载失败`);
+                })
+            } else {
+                console.error(`${url},不支持的格式`);
+            }
+
+            threeUtils.center(modal);
+            threeUtils.alignBottom(modal);
+            modal.updateMatrixWorld(true);
+
+            MeshBase.models.set(url, modal);
+            MeshBase.loadModeling.set(url, false);
+        }
+
+        // 如果模型还在加载中, 就等待模型加载完成
+        do {
+            await new Promise(resolve => setTimeout(resolve, 50));
+        } while (MeshBase.loadModeling.get(url));
+
+        if (MeshBase.models.get(url)) {
+
+            this.clear();
+            const mesh = MeshBase.models.get(url)!;
+            // // 判断是否有动画
+            // this.hasAnimation = mesh.animations.length > 0;
+
+            // if (this.hasAnimation) {
+            //     const model = SkeletonUtils.clone(mesh);
+            //     this.mixer = new AnimationMixer(model);
+
+            //     this.animationActions = {};
+            //     mesh.animations.map(animation => {
+            //         const animationAction = this.mixer!.clipAction(animation).play();
+            //         animationAction.weight = 0;
+            //         this.animationActions[animation.name] = animationAction;
+            //     });
+
+            //     this.add(model);
+            // } else {
+            //     this.add(mesh.clone(true));
+            // }
+
+            this.size.copy(threeUtils.getSize(mesh));
+
+            const { meshCollect, instanceCollect } = this
+
+            mesh.updateMatrixWorld(true);
+
+            // collect all mesh counts, in case there are more than one copy of the same mesh in this group
+            mesh.traverse((obj) => {
+                const mesh = obj as Mesh
+                if (mesh.isMesh) {
+
+                    mesh.matrixWorld.decompose(mesh.position, mesh.quaternion, mesh.scale);
+                    mesh.rotation.setFromQuaternion(mesh.quaternion);
+                    mesh.updateMatrix();
+
+                    // same geometry and same material consider as the same mesh
+                    const uuid = mesh.geometry.uuid + '/' + (mesh.material as Material).uuid
+
+                    if (meshCollect[uuid]) {
+                        meshCollect[uuid].push(mesh)
+                    } else {
+                        meshCollect[uuid] = [mesh]
+                    }
+                } else {
+                    obj.position.set(0, 0, 0);
+                    obj.scale.set(1, 1, 1);
+                    obj.rotation.set(0, 0, 0);
+                }
+
+            })
+
+            // create all instances
+            Object.keys(meshCollect).forEach(uuid => {
+                const meshes = meshCollect[uuid]
+                const mesh = meshes[0]
+                const instancedMesh = new InstancedMesh(mesh.geometry, mesh.material, meshes.length * this.count)
+                instancedMesh.name = mesh.name;
+                instancedMesh.frustumCulled = false;
+                instanceCollect[uuid] = instancedMesh
+                this.add(instancedMesh)
+            })
+
+            // 加载完成事件
+            await new Promise(resolve => setTimeout(resolve, 100));
+            // 加载完成事件
+            this.dispatchEvent({ type: "loaded" } as never);
+            this.loaded = true;
+        }
+
+    }
+
+
+    // 更新包围盒
+    computeBoundingSphere = throttle(() => {
+        this.traverse(m => {
+            (m as InstancedMesh).computeBoundingSphere();
+        })
+    }, 1000)
+
+    //初始实例矩阵的数量
+    setCount(count: number = 0) {
+
+
+        const instanceMatrix = new InstancedBufferAttribute(new Float32Array(count * 16), 16);
+        const instanceColor = new InstancedBufferAttribute(new Float32Array(count * 3).fill(1), 3);
+
+        for (let i = 0; i < this.count; i++) {
+            instanceMatrix.copyAt(i, this.instanceMatrix, i);
+            instanceColor.copyAt(i, this.instanceColor, i);
+        }
+
+        this.instanceMatrix = instanceMatrix;
+        this.instanceColor = instanceColor;
+        this.count = count;
+
+        this.children.map((instanceMesh: InstancedMesh) => {
+
+            const instanceMatrix = new InstancedBufferAttribute(new Float32Array(count * 16), 16);
+            const instanceColor = new InstancedBufferAttribute(new Float32Array(count * 3).fill(1), 3);
+
+            for (let i = 0; i < instanceMesh.count; i++) {
+                instanceMatrix.copyAt(i, this.instanceMatrix, i);
+                instanceColor.copyAt(i, this.instanceColor, i);
+            }
+
+            instanceMesh.instanceMatrix = instanceMatrix;
+            instanceMesh.instanceColor = instanceColor;
+            instanceMesh.count = count;
+        });
+
+    }
+
+    // 设置矩阵
+    setMatrixAt(index: number, matrix: Matrix4) {
+        Object.keys(this.meshCollect).forEach(uuid => {
+            const instancedMesh = this.instanceCollect[uuid]
+            const collect = this.meshCollect[uuid]
+            collect.forEach((mesh: Mesh, i: number) => {
+                InstancedMeshBase.matrix.copy(mesh.matrix)
+                InstancedMeshBase.matrix.premultiply(matrix)
+
+                instancedMesh.setMatrixAt(collect.length * index + i, InstancedMeshBase.matrix);
+                instancedMesh.instanceMatrix.needsUpdate = true;
+            })
+        })
+
+        this.computeBoundingSphere();
+    }
+
+    // 设置颜色
+    setColorAt(index: number, color: (instancedMesh: InstancedMesh) => Color | undefined) {
+        Object.keys(this.meshCollect).forEach(uuid => {
+            const instancedMesh = this.instanceCollect[uuid]
+            const collect = this.meshCollect[uuid]
+            collect.forEach((mesh: Mesh, i: number) => {
+                const c = color(instancedMesh);
+                if (c) {
+                    instancedMesh.setColorAt(collect.length * index + i, c);
+                    instancedMesh.instanceColor!.needsUpdate = true;
+                }
+            })
+        })
+    }
+
+    // 同步属性
+    updateMatrixWorld(force?: boolean): void {
+        super.updateMatrixWorld(force);
+        const { cursor, enableEvent } = this.userData;
+        this.traverse(obj => {
+            Object.assign(obj.userData, { cursor, enableEvent });
+        });
+    }
+
+    // 事件监听
+    addEventListener(name: string, callback: (e: any) => void) {
+        super.addEventListener(name, callback);
+        this.children.map(mesh => {
+            mesh.addEventListener(name, callback);
+        });
+    }
+
+    // 取消事件的监听
+    removeEventListener(name: string, callback: (e: any) => void) {
+        super.removeEventListener(name, callback);
+        this.children.map(mesh => {
+            mesh.removeEventListener(name, callback);
+        });
+    }
+
+}

package/ThreeBase.d.ts

@@ -52,7 +52,7 @@ export default class ThreeBase extends EventDispatcher {
     needRender: boolean;
     stopRender(): void;
     hasStrokeOrPass(): boolean;
-    render(): boolean;
+    render(): boolean | undefined;
     private renderBindThis;
     download(fileName?: string): void;
     private _preMesh;

package/ThreeBase.js

@@ -355,7 +355,7 @@ export default class ThreeBase extends EventDispatcher {
         // canvas 没有在页面上面的话 就停止渲染
         if (!threeUtils.inDocument(this.renderer.domElement)) {
             this.stopRender();
-            return;
+            return false;
         }
         //透视相机和正交相机参数的时时转换
         if (this.cameraType === "perspectiveCamera") {
@@ -534,9 +534,10 @@ export default class ThreeBase extends EventDispatcher {
         this.renderTargetgaussBlur(renderTarget, 1, 1);
         this.renderTargetgaussBlur(renderTarget, 1, 1);
     }
-    // 需要做康锯齿处理 渲染 渲染目标
+    // 需要做抗锯齿处理 渲染 渲染目标
     renderRendererTarget(renderTarget, alpha = false) {
         FXAAShaderMaterial.uniforms.tDiffuse.value = renderTarget.texture;
+        FXAAShaderMaterial.uniforms.resolution.value.set(1 / this.size.x, 1 / this.size.y);
         fullScreenMesh.material = FXAAShaderMaterial;
         fullScreenMesh.render(this.renderer);
         // const FXAAShaderMaterial = new ShaderMaterial({

package/ThreeBase.ts

@@ -424,11 +424,11 @@ export default class ThreeBase extends EventDispatcher {
     }
 
     // 渲染场景
-    render() {
+    render(): boolean | undefined {
         // canvas 没有在页面上面的话 就停止渲染
         if (!threeUtils.inDocument(this.renderer.domElement)) {
             this.stopRender();
-            return;
+            return false;
         }
 
         //透视相机和正交相机参数的时时转换
@@ -642,10 +642,11 @@ export default class ThreeBase extends EventDispatcher {
         this.renderTargetgaussBlur(renderTarget, 1, 1);
     }
 
-    // 需要做康锯齿处理 渲染 渲染目标
+    // 需要做抗锯齿处理 渲染 渲染目标
     renderRendererTarget(renderTarget: WebGLRenderTarget, alpha: boolean = false) {
 
         FXAAShaderMaterial.uniforms.tDiffuse.value = renderTarget.texture;
+        FXAAShaderMaterial.uniforms.resolution.value.set(1 / this.size.x, 1 / this.size.y);
         fullScreenMesh.material = FXAAShaderMaterial;
         fullScreenMesh.render(this.renderer);
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "three-base",
-    "version": "2.0.41",
+    "version": "2.0.43",
     "description": "three 3d three-base",
     "publishConfig": {
         "registry": "https://registry.npmjs.org/"

package/InstancedGroupMesh.js

@@ -1,106 +0,0 @@
-/*
- * @Author: xiaosihan
- * @Date: 2023-02-21 09:55:52
- * @Last Modified by: xiaosihan
- * @Last Modified time: 2024-01-27 17:41:26
- */
-import { throttle } from 'lodash';
-import { InstancedMesh, Matrix4, Mesh } from 'three';
-// 模型组转成 实例对象
-export default class InstancedGroupMesh extends Mesh {
-    isInstancedGroupMesh = true;
-    count = 0;
-    meshCollect = {};
-    instanceCollect = {};
-    static matrix = new Matrix4();
-    constructor(group, count) {
-        super();
-        this.count = count;
-        const { meshCollect, instanceCollect } = this;
-        group.updateMatrixWorld(true);
-        // collect all mesh counts, in case there are more than one copy of the same mesh in this group
-        group.traverse((obj) => {
-            const mesh = obj;
-            obj.userData = this.userData;
-            if (mesh.isMesh) {
-                mesh.matrixWorld.decompose(mesh.position, mesh.quaternion, mesh.scale);
-                mesh.rotation.setFromQuaternion(mesh.quaternion);
-                mesh.updateMatrix();
-                // same geometry and same material consider as the same mesh
-                const uuid = mesh.geometry.uuid + '/' + mesh.material.uuid;
-                if (meshCollect[uuid]) {
-                    meshCollect[uuid].push(mesh);
-                }
-                else {
-                    meshCollect[uuid] = [mesh];
-                }
-            }
-            else {
-                obj.position.set(0, 0, 0);
-                obj.scale.set(1, 1, 1);
-                obj.rotation.set(0, 0, 0);
-            }
-        });
-        // create all instances
-        Object.keys(meshCollect).forEach(uuid => {
-            const meshes = meshCollect[uuid];
-            const mesh = meshes[0];
-            const instancedMesh = new InstancedMesh(mesh.geometry, mesh.material, meshes.length * count);
-            instanceCollect[uuid] = instancedMesh;
-            this.add(instancedMesh);
-        });
-    }
-    // 更新包围盒
-    computeBoundingSphere = throttle(() => {
-        this.traverse(m => {
-            m.computeBoundingSphere();
-        });
-    }, 1000);
-    setMatrixAt(index, matrix) {
-        Object.keys(this.meshCollect).forEach(uuid => {
-            const instancedMesh = this.instanceCollect[uuid];
-            const collect = this.meshCollect[uuid];
-            collect.forEach((mesh, i) => {
-                InstancedGroupMesh.matrix.copy(mesh.matrix);
-                InstancedGroupMesh.matrix.premultiply(matrix);
-                instancedMesh.setMatrixAt(collect.length * index + i, InstancedGroupMesh.matrix);
-                instancedMesh.instanceMatrix.needsUpdate = true;
-            });
-        });
-        this.computeBoundingSphere();
-    }
-    // 设置颜色
-    setColorAt(index, color) {
-        Object.keys(this.meshCollect).forEach(uuid => {
-            const instancedMesh = this.instanceCollect[uuid];
-            const collect = this.meshCollect[uuid];
-            collect.forEach((mesh, i) => {
-                const c = color(instancedMesh);
-                if (c) {
-                    instancedMesh.setColorAt(collect.length * index + i, c);
-                    instancedMesh.instanceColor.needsUpdate = true;
-                }
-            });
-        });
-    }
-    // 同步属性
-    updateMatrixWorld(force) {
-        super.updateMatrixWorld(force);
-        const { cursor, enableEvent } = this.userData;
-        this.traverse(obj => {
-            Object.assign(obj.userData, { cursor, enableEvent });
-        });
-    }
-    // 事件监听
-    addEventListener(name, callback) {
-        this.children.map(mesh => {
-            mesh.addEventListener(name, callback);
-        });
-    }
-    // 取消事件的监听
-    removeEventListener(name, callback) {
-        this.children.map(mesh => {
-            mesh.removeEventListener(name, callback);
-        });
-    }
-}

package/InstancedGroupMesh.ts

@@ -1,133 +0,0 @@
-/*
- * @Author: xiaosihan 
- * @Date: 2023-02-21 09:55:52 
- * @Last Modified by: xiaosihan
- * @Last Modified time: 2024-01-27 17:41:26
- */
-
-import { throttle } from 'lodash';
-import { Color, Group, InstancedMesh, Material, Matrix4, Mesh } from 'three';
-
-// 模型组转成 实例对象
-export default class InstancedGroupMesh extends Mesh {
-
-    declare children: InstancedMesh[];
-
-    isInstancedGroupMesh = true
-
-    count: number = 0;
-
-    meshCollect: Record<string, Mesh[]> = {}
-
-    instanceCollect: Record<string, InstancedMesh> = {}
-
-    static matrix = new Matrix4()
-
-    constructor(group: Group, count: number) {
-        super()
-        this.count = count
-
-        const { meshCollect, instanceCollect } = this
-
-        group.updateMatrixWorld(true);
-
-        // collect all mesh counts, in case there are more than one copy of the same mesh in this group
-        group.traverse((obj) => {
-            const mesh = obj as Mesh;
-
-            obj.userData = this.userData;
-
-            if (mesh.isMesh) {
-
-                mesh.matrixWorld.decompose(mesh.position, mesh.quaternion, mesh.scale);
-                mesh.rotation.setFromQuaternion(mesh.quaternion);
-                mesh.updateMatrix();
-
-                // same geometry and same material consider as the same mesh
-                const uuid = mesh.geometry.uuid + '/' + (mesh.material as Material).uuid
-
-                if (meshCollect[uuid]) {
-                    meshCollect[uuid].push(mesh)
-                } else {
-                    meshCollect[uuid] = [mesh]
-                }
-            } else {
-                obj.position.set(0, 0, 0);
-                obj.scale.set(1, 1, 1);
-                obj.rotation.set(0, 0, 0);
-            }
-
-        })
-
-        // create all instances
-        Object.keys(meshCollect).forEach(uuid => {
-            const meshes = meshCollect[uuid]
-            const mesh = meshes[0]
-
-            const instancedMesh = new InstancedMesh(mesh.geometry, mesh.material, meshes.length * count)
-            instanceCollect[uuid] = instancedMesh;
-            this.add(instancedMesh)
-        })
-    }
-
-    // 更新包围盒
-    computeBoundingSphere = throttle(() => {
-        this.traverse(m => {
-            (m as InstancedMesh).computeBoundingSphere();
-        })
-    }, 1000)
-
-    setMatrixAt(index: number, matrix: Matrix4) {
-        Object.keys(this.meshCollect).forEach(uuid => {
-            const instancedMesh = this.instanceCollect[uuid]
-            const collect = this.meshCollect[uuid]
-            collect.forEach((mesh: Mesh, i: number) => {
-                InstancedGroupMesh.matrix.copy(mesh.matrix)
-                InstancedGroupMesh.matrix.premultiply(matrix)
-                instancedMesh.setMatrixAt(collect.length * index + i, InstancedGroupMesh.matrix);
-                instancedMesh.instanceMatrix.needsUpdate = true;
-            })
-        })
-        this.computeBoundingSphere();
-    }
-
-    // 设置颜色
-    setColorAt(index: number, color: (instancedMesh: InstancedMesh) => Color | undefined) {
-        Object.keys(this.meshCollect).forEach(uuid => {
-            const instancedMesh = this.instanceCollect[uuid]
-            const collect = this.meshCollect[uuid]
-            collect.forEach((mesh: Mesh, i: number) => {
-                const c = color(instancedMesh);
-                if (c) {
-                    instancedMesh.setColorAt(collect.length * index + i, c);
-                    instancedMesh.instanceColor!.needsUpdate = true;
-                }
-            })
-        })
-    }
-
-    // 同步属性
-    updateMatrixWorld(force?: boolean): void {
-        super.updateMatrixWorld(force);
-        const { cursor, enableEvent } = this.userData;
-        this.traverse(obj => {
-            Object.assign(obj.userData, { cursor, enableEvent });
-        });
-    }
-
-    // 事件监听
-    addEventListener(name: string, callback: (e: any) => void) {
-        this.children.map(mesh => {
-            mesh.addEventListener(name, callback);
-        });
-    }
-
-    // 取消事件的监听
-    removeEventListener(name: string, callback: (e: any) => void) {
-        this.children.map(mesh => {
-            mesh.removeEventListener(name, callback);
-        });
-    }
-
-}
-

package/InstancedMeshBase/InstancedMeshBase.d.ts

@@ -1,4 +0,0 @@
-import { Group } from "three";
-export default class InstancedMeshBase extends Group {
-    constructor();
-}

package/InstancedMeshBase/InstancedMeshBase.js

@@ -1,13 +0,0 @@
-/*
- * @Author: xiaosihan
- * @Date: 2024-02-05 09:31:57
- * @Last Modified by: xiaosihan
- * @Last Modified time: 2024-02-05 09:40:12
- */
-import { Group } from "three";
-// 数组实例模型
-export default class InstancedMeshBase extends Group {
-    constructor() {
-        super();
-    }
-}

package/InstancedMeshBase/InstancedMeshBase.ts

@@ -1,18 +0,0 @@
-/*
- * @Author: xiaosihan 
- * @Date: 2024-02-05 09:31:57 
- * @Last Modified by: xiaosihan
- * @Last Modified time: 2024-02-05 09:40:12
- */
-
-import { Group } from "three";
-
-// 数组实例模型
-export default class InstancedMeshBase extends Group {
-    constructor() {
-        super();
-    }
-
-
-    
-}