three-base 2.0.67 → 2.0.68

package/InstancedMeshBase.js

@@ -1,190 +1,190 @@
-/*
- * @Author: xiaosihan
- * @Date: 2024-02-05 09:31:57
- * @Last Modified by: xiaosihan
- * @Last Modified time: 2024-06-07 22:14:53
- */
-import { throttle } from "lodash";
-import { InstancedBufferAttribute, InstancedMesh, Matrix4, 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, filename = "") {
-        if (!url) {
-            this.clear();
-            return;
-        }
-        this.loaded = false;
-        // 没有模型并且没有加载任务时就去加载模型
-        if (!MeshBase.models.get(url) && !MeshBase.loadModeling.get(url)) {
-            MeshBase.loadModeling.set(url, true);
-            // 万能加载器
-            let modal = await threeLoader.loadModel(url, filename);
-            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 => {
-            if (m !== this) {
-                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);
-        });
-    }
-}
+/*
+ * @Author: xiaosihan
+ * @Date: 2024-02-05 09:31:57
+ * @Last Modified by: xiaosihan
+ * @Last Modified time: 2024-06-07 22:14:53
+ */
+import { throttle } from "lodash";
+import { InstancedBufferAttribute, InstancedMesh, Matrix4, 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, filename = "") {
+        if (!url) {
+            this.clear();
+            return;
+        }
+        this.loaded = false;
+        // 没有模型并且没有加载任务时就去加载模型
+        if (!MeshBase.models.get(url) && !MeshBase.loadModeling.get(url)) {
+            MeshBase.loadModeling.set(url, true);
+            // 万能加载器
+            let modal = await threeLoader.loadModel(url, filename);
+            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 => {
+            if (m !== this) {
+                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/KeyFrameAnimation.d.ts

@@ -1,25 +1,25 @@
-import { Euler, Line, LineBasicMaterial, Object3D, Vector3 } from "three";
-export type Keyframe = {
-    position: Vector3;
-    scale: Vector3;
-    rotation: Euler;
-    timeTemp: number;
-};
-export type KeyframeAnimationProps = {
-    speedScale?: number;
-    object3d: Object3D;
-    keyframes: Array<Keyframe>;
-};
-export default class KeyframeAnimation extends Object3D {
-    constructor(props: KeyframeAnimationProps);
-    speedScale: number;
-    object3d: Object3D;
-    halperLine: Line<any, LineBasicMaterial>;
-    keyframes: Array<Keyframe>;
-    setObject3D(object3d: Object3D): void;
-    getKeyframe(i: number): Keyframe;
-    setKeyframe(i: number, keyframe: Keyframe): void;
-    setKeyframes(keyframes: Array<Keyframe>): void;
-    update(): void;
-    updateMatrix(): void;
-}
+import { Euler, Line, LineBasicMaterial, Object3D, Vector3 } from "three";
+export type Keyframe = {
+    position: Vector3;
+    scale: Vector3;
+    rotation: Euler;
+    timeTemp: number;
+};
+export type KeyframeAnimationProps = {
+    speedScale?: number;
+    object3d: Object3D;
+    keyframes: Array<Keyframe>;
+};
+export default class KeyframeAnimation extends Object3D {
+    constructor(props: KeyframeAnimationProps);
+    speedScale: number;
+    object3d: Object3D;
+    halperLine: Line<any, LineBasicMaterial>;
+    keyframes: Array<Keyframe>;
+    setObject3D(object3d: Object3D): void;
+    getKeyframe(i: number): Keyframe;
+    setKeyframe(i: number, keyframe: Keyframe): void;
+    setKeyframes(keyframes: Array<Keyframe>): void;
+    update(): void;
+    updateMatrix(): void;
+}

package/KeyFrameAnimation.js

@@ -1,78 +1,78 @@
-/*
- * @Author: xiaosihan
- * @Date: 2023-02-16 00:22:31
- * @Last Modified by: xiaosihan
- * @Last Modified time: 2023-02-16 19:08:55
- */
-import { last } from "lodash";
-import { BufferAttribute, Line, LineBasicMaterial, Object3D } from "three";
-import threeUtils from "./threeUtils";
-// 关键帧动画对象
-export default class KeyframeAnimation extends Object3D {
-    constructor(props) {
-        super();
-        // 速度调整
-        this.speedScale = props.speedScale || 1;
-        // 设置关键帧对象数组
-        this.setKeyframes(props.keyframes);
-        // 设置对象
-        this.setObject3D(props.object3d);
-    }
-    // 速度调整
-    speedScale = 1;
-    // 需要需要移动的对象
-    object3d;
-    //路径辅助线
-    halperLine = new Line(undefined, new LineBasicMaterial({ color: "#f00" }));
-    // 关键帧数组
-    keyframes = [];
-    // 设置需要移动的对象
-    setObject3D(object3d) {
-        this.object3d = object3d;
-        if (threeUtils.isDev) {
-            this.children = [object3d, this.halperLine];
-        }
-        else {
-            this.children = [object3d];
-        }
-    }
-    // 获取单个关键帧
-    getKeyframe(i) {
-        return this.keyframes[i];
-    }
-    // 设置单个关键帧
-    setKeyframe(i, keyframe) {
-        this.keyframes[i] = keyframe;
-        this.setKeyframes(this.keyframes);
-    }
-    //设置全部关键帧
-    setKeyframes(keyframes) {
-        this.keyframes = keyframes;
-        const position = [];
-        keyframes.map(k => {
-            position.push(k.position.x);
-            position.push(k.position.y);
-            position.push(k.position.z);
-        });
-        this.halperLine.geometry.setAttribute("position", new BufferAttribute(new Float32Array(position), 3, false));
-    }
-    // 更具关键帧的信息更新 对象的位置
-    update() {
-        const { _timeTemp } = threeUtils;
-        const maxtimetemp = last(this.keyframes).timeTemp;
-        const currentTime = _timeTemp % maxtimetemp;
-        const currentKeyframeIndex = this.keyframes.findIndex(k => currentTime < k.timeTemp);
-        const startKeyframe = this.keyframes[currentKeyframeIndex - 1];
-        const endKeyframe = this.keyframes[currentKeyframeIndex];
-        const progress = (currentTime - startKeyframe.timeTemp) / (endKeyframe.timeTemp - startKeyframe.timeTemp);
-        this.object3d.position.copy(endKeyframe.position).sub(startKeyframe.position).multiplyScalar(progress).add(startKeyframe.position);
-        this.object3d.scale.copy(endKeyframe.scale).sub(startKeyframe.scale).multiplyScalar(progress).add(startKeyframe.scale);
-        this.object3d.rotation.set((endKeyframe.rotation.x - startKeyframe.rotation.x) * progress + startKeyframe.rotation.x, (endKeyframe.rotation.y - startKeyframe.rotation.y) * progress + startKeyframe.rotation.y, (endKeyframe.rotation.z - startKeyframe.rotation.z) * progress + startKeyframe.rotation.z);
-        this.dispatchEvent({ type: "update" });
-    }
-    //更新关键帧的实例矩阵
-    updateMatrix() {
-        this.update();
-        super.updateMatrix();
-    }
-}
+/*
+ * @Author: xiaosihan
+ * @Date: 2023-02-16 00:22:31
+ * @Last Modified by: xiaosihan
+ * @Last Modified time: 2023-02-16 19:08:55
+ */
+import { last } from "lodash";
+import { BufferAttribute, Line, LineBasicMaterial, Object3D } from "three";
+import threeUtils from "./threeUtils";
+// 关键帧动画对象
+export default class KeyframeAnimation extends Object3D {
+    constructor(props) {
+        super();
+        // 速度调整
+        this.speedScale = props.speedScale || 1;
+        // 设置关键帧对象数组
+        this.setKeyframes(props.keyframes);
+        // 设置对象
+        this.setObject3D(props.object3d);
+    }
+    // 速度调整
+    speedScale = 1;
+    // 需要需要移动的对象
+    object3d;
+    //路径辅助线
+    halperLine = new Line(undefined, new LineBasicMaterial({ color: "#f00" }));
+    // 关键帧数组
+    keyframes = [];
+    // 设置需要移动的对象
+    setObject3D(object3d) {
+        this.object3d = object3d;
+        if (threeUtils.isDev) {
+            this.children = [object3d, this.halperLine];
+        }
+        else {
+            this.children = [object3d];
+        }
+    }
+    // 获取单个关键帧
+    getKeyframe(i) {
+        return this.keyframes[i];
+    }
+    // 设置单个关键帧
+    setKeyframe(i, keyframe) {
+        this.keyframes[i] = keyframe;
+        this.setKeyframes(this.keyframes);
+    }
+    //设置全部关键帧
+    setKeyframes(keyframes) {
+        this.keyframes = keyframes;
+        const position = [];
+        keyframes.map(k => {
+            position.push(k.position.x);
+            position.push(k.position.y);
+            position.push(k.position.z);
+        });
+        this.halperLine.geometry.setAttribute("position", new BufferAttribute(new Float32Array(position), 3, false));
+    }
+    // 更具关键帧的信息更新 对象的位置
+    update() {
+        const { _timeTemp } = threeUtils;
+        const maxtimetemp = last(this.keyframes).timeTemp;
+        const currentTime = _timeTemp % maxtimetemp;
+        const currentKeyframeIndex = this.keyframes.findIndex(k => currentTime < k.timeTemp);
+        const startKeyframe = this.keyframes[currentKeyframeIndex - 1];
+        const endKeyframe = this.keyframes[currentKeyframeIndex];
+        const progress = (currentTime - startKeyframe.timeTemp) / (endKeyframe.timeTemp - startKeyframe.timeTemp);
+        this.object3d.position.copy(endKeyframe.position).sub(startKeyframe.position).multiplyScalar(progress).add(startKeyframe.position);
+        this.object3d.scale.copy(endKeyframe.scale).sub(startKeyframe.scale).multiplyScalar(progress).add(startKeyframe.scale);
+        this.object3d.rotation.set((endKeyframe.rotation.x - startKeyframe.rotation.x) * progress + startKeyframe.rotation.x, (endKeyframe.rotation.y - startKeyframe.rotation.y) * progress + startKeyframe.rotation.y, (endKeyframe.rotation.z - startKeyframe.rotation.z) * progress + startKeyframe.rotation.z);
+        this.dispatchEvent({ type: "update" });
+    }
+    //更新关键帧的实例矩阵
+    updateMatrix() {
+        this.update();
+        super.updateMatrix();
+    }
+}

package/MeshBase.d.ts

@@ -1,32 +1,32 @@
-import { AnimationAction, AnimationMixer, Clock, Group, Mesh, Object3D, Vector3 } from "three";
-export default class MeshBase extends Group {
-    constructor(url?: string);
-    static models: Map<string, Object3D>;
-    static loadModeling: Map<string, boolean>;
-    loaded: boolean;
-    hasAnimation: boolean;
-    mixer?: AnimationMixer;
-    animationActions: {
-        [key: string]: AnimationAction;
-    };
-    getSuffix(filename: string): string;
-    loadModel(url: string, filename?: string): Promise<void>;
-    frustumCulled: boolean;
-    castShadow: boolean;
-    receiveShadow: boolean;
-    awaitLoaded(callback?: Function): Promise<void>;
-    traverseMesh(callback: (mesh: Mesh) => void): Promise<void>;
-    clock: Clock;
-    setClipActionWeight(weights?: {
-        [key: string]: number;
-    }): Promise<void>;
-    getAnimas(): string[];
-    setAnimas(anima?: string): void;
-    stop(): void;
-    updateMatrix(): void;
-    getSize(): Promise<Vector3>;
-    center(): Promise<void>;
-    alignBottom(y?: number): Promise<void>;
-    scaleTo(size?: number, key?: Array<"x" | "y" | "z">): Promise<void>;
-    expandBynormal(length: number): void;
-}
+import { AnimationAction, AnimationMixer, Clock, Group, Mesh, Object3D, Vector3 } from "three";
+export default class MeshBase extends Group {
+    constructor(url?: string);
+    static models: Map<string, Object3D>;
+    static loadModeling: Map<string, boolean>;
+    loaded: boolean;
+    hasAnimation: boolean;
+    mixer?: AnimationMixer;
+    animationActions: {
+        [key: string]: AnimationAction;
+    };
+    getSuffix(filename: string): string;
+    loadModel(url: string, filename?: string): Promise<void>;
+    frustumCulled: boolean;
+    castShadow: boolean;
+    receiveShadow: boolean;
+    awaitLoaded(callback?: Function): Promise<void>;
+    traverseMesh(callback: (mesh: Mesh) => void): Promise<void>;
+    clock: Clock;
+    setClipActionWeight(weights?: {
+        [key: string]: number;
+    }): Promise<void>;
+    getAnimas(): string[];
+    setAnimas(anima?: string): void;
+    stop(): void;
+    updateMatrix(): void;
+    getSize(): Promise<Vector3>;
+    center(): Promise<void>;
+    alignBottom(y?: number): Promise<void>;
+    scaleTo(size?: number, key?: Array<"x" | "y" | "z">): Promise<void>;
+    expandBynormal(length: number): void;
+}