three-base 2.0.137 → 2.0.142

package/threeUtils.ts

@@ -0,0 +1,373 @@
+/*
+ * @Author: xiaosihan
+ * @Date: 2022-02-24 22:49:42
+ * @Last Modified by: xiaosihan
+ * @Last Modified time: 2023-05-03 00:36:18
+ */
+import { Box3, BufferGeometry, Clock, EventDispatcher, Material, Mesh, MeshBasicMaterial, MeshLambertMaterial, Object3D, Vector3 } from "three";
+import { MathUtils } from "three";
+const { generateUUID } = MathUtils;
+import { GLTFExporter } from "three/examples/jsm/exporters/GLTFExporter";
+import type { ThreeUtilsEventTypeMap } from "./EventMap";
+
+interface KeepZoomDom {
+    dom: HTMLElement;
+    width: number;
+    height: number;
+}
+
+class ThreeUtils extends EventDispatcher<ThreeUtilsEventTypeMap> {
+    constructor() {
+        super();
+        this.requestAnimationFrame();
+    }
+
+    isProd: boolean = typeof process !== 'undefined' && process.env?.NODE_ENV === "production";
+
+    isDev: boolean = typeof process !== 'undefined' && process.env?.NODE_ENV === "development";
+
+    _timeTemp: number = performance.now();
+
+    _accumulate: number = 0; // 事件分发次数
+
+    _box3: Box3 = new Box3();
+
+    _size: Vector3 = new Vector3();
+
+    _center: Vector3 = new Vector3();
+
+    _clock: Clock = new Clock();
+
+    requestAnimationFrame(): void {
+        this._accumulate += 1;
+        const timeTemp = (this._timeTemp = performance.now());
+        this.dispatchEvent({
+            type: "requestAnimationFrame",
+            timeTemp,
+            accumulate: this._accumulate,
+        });
+        this._computerDomZoom();
+        //执行一个计划任务
+        let work = this.workList.splice(0, 1)[0];
+        work && work();
+        setTimeout(() => {
+            this.requestAnimationFrame();
+        }, 30 - this._clock.getDelta());
+    }
+
+    // 需要保持宽高比的元素列表
+    private _keepZoomDoms: KeepZoomDom[] = [];
+
+    /**
+     *计算需要保持比例的元素
+     */
+    private _computerDomZoom(): void {
+        //1. 踢除没有出现在页面上的 dom 元素
+        this._keepZoomDoms = this._keepZoomDoms.filter((l) => this.inDocument(l.dom));
+        //2.设置dom的缩放值样式
+        this._keepZoomDoms.map((item, i) => {
+            let parentDom = item.dom.parentNode as HTMLElement;
+            let scale = Math.min(parentDom.clientWidth / item.width, parentDom.clientHeight / item.height);
+            Object.assign(item.dom.style, {
+                position: "absolute",
+                top: "50%",
+                left: "50%",
+                transform: `translate(-50%, -50%) scale(${scale})`,
+                width: `${item.width}px`,
+                height: `${item.height}px`,
+            });
+        });
+    }
+
+    /**
+     * dom元素保持比例
+     */
+    keepZoom(dom: HTMLElement | null, width: number = 1920, height: number = 1080): void {
+        if (dom) {
+            // 去掉相同的dom存储的信息
+            this._keepZoomDoms = this._keepZoomDoms.filter((l) => l.dom !== dom);
+            // 把配置加入到列表中
+            this._keepZoomDoms.push({ dom, width, height });
+            dom.dataset.a = "这个元素缩放比例由 threeUtils.keepZoom 方法设置";
+            this._computerDomZoom();
+        }
+    }
+
+    workList: Array<() => void> = [];
+
+    // 时钟对象
+    clock: Clock = new Clock();
+
+    // 按照任务队列依次执行计划任务 性能优化
+    /**
+     * @param {() => void} [callback]
+     * @param {boolean} [first=true] 需要优先执行
+     */
+    addWork(work?: () => void, first: boolean = false): void {
+        // 加入任务队列
+        if (work && !this.workList.includes(work)) {
+            if (first) {
+                this.workList.splice(1, 0, work); // 优先执行的任务回调
+            }
+            else {
+                this.workList.push(work);
+            }
+        }
+    }
+
+    /**
+     *判断一个元素是否在页面上
+     */
+    inDocument(dom: ParentNode | null): boolean {
+        if (dom === null) {
+            return false;
+        }
+        else if (dom.parentNode === null) {
+            return false;
+        }
+        else if (dom.parentNode === document) {
+            return true;
+        }
+        else {
+            return this.inDocument(dom.parentNode);
+        }
+    }
+
+    // 获取中心点
+    getCenter(object3d: Object3D | BufferGeometry): Vector3 {
+        if (object3d instanceof Object3D) {
+            this._box3.setFromObject(object3d);
+            this._box3.getCenter(this._center);
+        }
+        else if (object3d instanceof BufferGeometry) {
+            object3d.computeBoundingBox();
+            object3d.boundingBox!.getCenter(this._center);
+        }
+        return this._center.clone();
+    }
+
+    // 获取模型大小
+    getSize(object3d: Object3D | BufferGeometry): Vector3 {
+        if (object3d instanceof Object3D) {
+            this._box3.setFromObject(object3d);
+            this._box3.getSize(this._size);
+        }
+        else if (object3d instanceof BufferGeometry) {
+            object3d.computeBoundingBox();
+            object3d.boundingBox!.getSize(this._size);
+        }
+        return this._size.clone();
+    }
+
+    // 模型对齐底面
+    alignBottom(object3d: Object3D | BufferGeometry, y: number = 0): void {
+        if (object3d instanceof Object3D) {
+            this._box3.setFromObject(object3d);
+            this._box3.getCenter(this._center);
+            this._box3.getSize(this._size);
+            object3d.position.y -= this._center.y - this._size.y * 0.5;
+            object3d.position.y += y;
+            object3d.updateMatrixWorld(true);
+        }
+        else if (object3d instanceof BufferGeometry) {
+            object3d.computeBoundingBox();
+            object3d.translate(0, -object3d.boundingBox!.min.y + y, 0);
+        }
+    }
+
+    // 居中对象
+    centerObject3D(object3d: Object3D | BufferGeometry): void {
+        if (object3d instanceof Object3D) {
+            this._box3.setFromObject(object3d);
+            this._box3.getCenter(this._center);
+            object3d.position.sub(this._center);
+            object3d.updateMatrixWorld(true);
+        }
+        else if (object3d instanceof BufferGeometry) {
+            object3d.center();
+        }
+    }
+
+    //居中对象
+    center(object3d: Object3D | BufferGeometry): void {
+        this.centerObject3D(object3d);
+    }
+
+    // 使用指定的维度(xyz)计算, 缩放至指定大小;
+    scaleTo(object3d: Object3D | BufferGeometry, size: number = 1, key: Array<"x" | "y" | "z"> = ["x", "y", "z"]): void {
+        const originSize = this.getSize(object3d);
+        const scale = size / Math.max(...key.map((k) => originSize[k]));
+        if ((object3d as Object3D).isObject3D) {
+            (object3d as Object3D).scale.multiplyScalar(scale);
+            (object3d as Object3D).updateMatrixWorld(true);
+        }
+        else if ((object3d as BufferGeometry).isBufferGeometry) {
+            (object3d as BufferGeometry).scale(scale, scale, scale);
+        }
+    }
+
+    // 应用全部变化
+    applyAllTranstion(object3d: Object3D): void {
+        object3d.updateMatrixWorld(true);
+        // 应用全部变换
+        object3d.traverse((obj) => {
+            obj.position.set(0, 0, 0);
+            obj.rotation.set(0, 0, 0);
+            obj.scale.set(1, 1, 1);
+            if (obj instanceof Mesh) {
+                obj.geometry.applyMatrix4(obj.matrixWorld);
+            }
+        });
+    }
+
+    // 导出 glb
+    exportGLB(input: Object3D, fileName: string = "threeUtils.exportGLB", maxTextureSize: number = 4096): void {
+        const gltfExporter = new GLTFExporter();
+        gltfExporter.parse(input, (result) => {
+            if (result instanceof ArrayBuffer) {
+                const link = document.createElement("a");
+                link.style.display = "none";
+                document.body.appendChild(link); // Firefox workaround, see #6594
+                link.href = URL.createObjectURL(new Blob([result], { type: "application/octet-stream" }));
+                link.download = `${fileName}.glb`;
+                link.click();
+            }
+        }, (error) => { }, {
+            trs: true,
+            onlyVisible: true, // 只导出可见的
+            binary: true, // glb
+            maxTextureSize: maxTextureSize,
+        });
+    }
+
+    //导出usdz
+    exportUsdz(): void { }
+
+    // 计算网格的体积
+    getVolume(geometry: BufferGeometry): number {
+        if (!geometry.index)
+            return 0;
+        if (!geometry.isBufferGeometry) {
+            console.warn("'geometry' must be an indexed or non-indexed buffer geometry");
+            return 0;
+        }
+        const isIndexed = geometry.index !== null;
+        const position = geometry.attributes.position;
+        let sum = 0;
+        const p1 = new Vector3(), p2 = new Vector3(), p3 = new Vector3();
+        if (!isIndexed) {
+            const faces = position.count / 3;
+            for (let i = 0; i < faces; i++) {
+                p1.fromBufferAttribute(position, i * 3 + 0);
+                p2.fromBufferAttribute(position, i * 3 + 1);
+                p3.fromBufferAttribute(position, i * 3 + 2);
+                sum += this.signedVolumeOfTriangle(p1, p2, p3);
+            }
+        }
+        else {
+            const index = geometry.index;
+            const faces = index.count / 3;
+            for (let i = 0; i < faces; i++) {
+                p1.fromBufferAttribute(position, index.array[i * 3 + 0]);
+                p2.fromBufferAttribute(position, index.array[i * 3 + 1]);
+                p3.fromBufferAttribute(position, index.array[i * 3 + 2]);
+                sum += this.signedVolumeOfTriangle(p1, p2, p3);
+            }
+        }
+        return sum > 0 ? sum : 0;
+    }
+
+    signedVolumeOfTriangle(p1: Vector3, p2: Vector3, p3: Vector3): number {
+        return p1.dot(p2.cross(p3)) / 6.0;
+    }
+
+    //清理对象的网格和材质的缓存
+    dipose(object3d: Object3D): void {
+        object3d.traverse((obj) => {
+            if (obj instanceof Mesh) {
+                obj.geometry.dispose();
+                if (obj.material instanceof Material) {
+                    obj.material.dispose();
+                }
+                else if (obj.material instanceof Array) {
+                    obj.material.map((m: Material) => {
+                        m.dispose();
+                    });
+                }
+            }
+        });
+    }
+
+    // 获取文件名的后缀
+    getSuffix(filename: string): string {
+        const match = filename.match(/([^\.]+)$/);
+        return match ? match[1].toLowerCase() : "";
+    }
+
+    // 从url 中提取文件名
+    getFilename(url: string): string {
+        // 移除URL的查询字符串和哈希部分
+        const path = url.split("?")[0].split("#")[0];
+        // 使用lastIndexOf和substring从路径中提取文件名
+        const filename = path.substring(path.lastIndexOf("/") + 1);
+        return filename;
+    }
+
+    //文件转blob
+    fileToBloburl(file: File): Promise<string> {
+        return new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.onload = function (event) {
+                const arrayBuffer = event.target!.result;
+                const blob = new Blob([arrayBuffer]);
+                const bloburl = URL.createObjectURL(blob);
+                resolve(bloburl);
+            };
+            reader.onerror = function (error) {
+                throw new Error(`文件转blbo 失败,${file.name}`);
+            };
+            reader.readAsArrayBuffer(file);
+        });
+    }
+
+    //材质转为基础材质
+    toMeshBasicMaterial<P extends Material | Material[]>(material: P): P {
+        if (material instanceof Array) {
+            return material.map((m) => this.toMeshBasicMaterial(m)) as P;
+        }
+        else {
+            const meshBasicMaterial = new MeshBasicMaterial();
+            for (let i in meshBasicMaterial) {
+                if (!["type"].includes(i) &&
+                    meshBasicMaterial.hasOwnProperty(i) &&
+                    (material as unknown as { [key: string]: unknown }).hasOwnProperty(i)) {
+                    (meshBasicMaterial as unknown as { [key: string]: unknown })[i] = (material as unknown as { [key: string]: unknown })[i];
+                }
+            }
+            return meshBasicMaterial as unknown as P;
+        }
+    }
+
+    toMeshLambertMaterial<P extends Material | Material[]>(material: P): P {
+        if (material instanceof Array) {
+            return material.map((m) => this.toMeshLambertMaterial(m)) as P;
+        }
+        else {
+            const meshLambertMaterial = new MeshLambertMaterial();
+            for (let i in meshLambertMaterial) {
+                if (!["type"].includes(i) &&
+                    meshLambertMaterial.hasOwnProperty(i) &&
+                    (material as unknown as { [key: string]: unknown }).hasOwnProperty(i)) {
+                    (meshLambertMaterial as unknown as { [key: string]: unknown })[i] = (material as unknown as { [key: string]: unknown })[i];
+                }
+            }
+            return meshLambertMaterial as unknown as P;
+        }
+    }
+}
+
+const threeUtils: ThreeUtils = new ThreeUtils();
+
+(window as unknown as Record<string, unknown>).threeUtils = threeUtils;
+
+export default threeUtils;

package/types.d.ts

@@ -0,0 +1,2 @@
+/** 颜色字符串：十六进制或 rgb/rgba */
+export type ColorString = `rgb(${string})` | `rgba(${string})` | `#${string}`;

package/types.js

@@ -0,0 +1,6 @@
+/*
+ * @Author: xiaosihan
+ * @Date: 2026-08-15
+ * @Description: three-base 公共运行时类型。
+ */
+export {};

package/types.ts

@@ -0,0 +1,8 @@
+/*
+ * @Author: xiaosihan
+ * @Date: 2026-08-15
+ * @Description: three-base 公共运行时类型。
+ */
+
+/** 颜色字符串：十六进制或 rgb/rgba */
+export type ColorString = `rgb(${string})` | `rgba(${string})` | `#${string}`;

package/ApngTexture.d.ts

@@ -1,13 +0,0 @@
-import { APNG } from "apng-js";
-import Player from "apng-js/types/library/player";
-import { CanvasTexture } from "three";
-export default class ApngTexture extends CanvasTexture {
-    constructor(url: string);
-    static TimeTemp: number;
-    preUpdate: number;
-    player?: Player;
-    apng?: APNG;
-    onUpdate: () => void;
-    getUuid(): number | "";
-    loadApng(url: string): Promise<void>;
-}

package/ApngTexture.js

@@ -1,61 +0,0 @@
-import parseAPNG from "apng-js";
-import axios from "axios";
-import { CanvasTexture } from "three";
-import threeUtils from "./threeUtils";
-export default class ApngTexture extends CanvasTexture {
-    constructor(url) {
-        super(document.createElement("canvas"));
-        this.loadApng(url);
-    }
-    // 获取时间戳
-    static TimeTemp = performance.now();
-    // 上一次更新时间
-    preUpdate = 0;
-    player;
-    // apng 对象
-    apng;
-    // 更新纹理
-    onUpdate = () => {
-        if (this.preUpdate === ApngTexture.TimeTemp) {
-            return;
-        }
-        this.preUpdate = ApngTexture.TimeTemp;
-        if (this.player) {
-            this.player.renderNextFrame();
-        }
-    };
-    // 获取当前帧id
-    getUuid() {
-        if (this.apng) {
-            let currentTime = ApngTexture.TimeTemp % this.apng.playTime;
-            let i = 0;
-            while (this.apng.frames[i] && currentTime > this.apng.frames[i].delay) {
-                currentTime -= this.apng.frames[i].delay;
-                i++;
-            }
-            return this.apng.frames[i].delay;
-        }
-        else {
-            return "";
-        }
-    }
-    // 加载apng图片
-    async loadApng(url) {
-        const res = await axios.get(url, { method: "post", responseType: "blob" });
-        const blob = new Blob([res.data]);
-        const reader = new FileReader();
-        await new Promise((resolve) => {
-            reader.onload = () => resolve();
-            reader.readAsArrayBuffer(blob);
-        });
-        const apng = parseAPNG(reader.result);
-        this.dispose();
-        this.image.width = apng.width;
-        this.image.height = apng.height;
-        this.player = await apng.getPlayer(this.image.getContext("2d"));
-    }
-}
-// 定时更新时间戳
-threeUtils.addEventListener("requestAnimationFrame", (e) => {
-    ApngTexture.TimeTemp = e.timeTemp;
-});

package/ApngTextureManage.d.ts

@@ -1,18 +0,0 @@
-import { Texture, TextureLoader } from "three";
-/**
- * apng 纹理管理对象
- */
-declare class apngTextureManage {
-    constructor();
-    static TextureLoader: TextureLoader;
-    static isInit: boolean;
-    static TimeTemp: number;
-    playTimes: Map<any, any>;
-    anpgTextList: {
-        [key: string]: Texture[];
-    };
-    getTexture(path: string): Texture;
-    loadApng(url: string): Promise<void>;
-}
-declare const ApngTextureManage: apngTextureManage;
-export default ApngTextureManage;

package/ApngTextureManage.js

@@ -1,87 +0,0 @@
-import parseAPNG from "apng-js";
-import axios from "axios";
-import { isEmpty } from "lodash";
-import { MirroredRepeatWrapping, TextureLoader } from "three";
-import threeUtils from "./threeUtils";
-/**
- * apng 纹理管理对象
- */
-class apngTextureManage {
-    constructor() {
-        // 初始化定时更新时间戳
-        if (apngTextureManage.isInit) {
-            apngTextureManage.isInit = false;
-            threeUtils.addEventListener("requestAnimationFrame5000", (e) => {
-                apngTextureManage.TimeTemp = e.timeTemp;
-            });
-        }
-    }
-    static TextureLoader = new TextureLoader();
-    static isInit = true;
-    // 获取时间戳
-    static TimeTemp = performance.now();
-    // 每个动态纹理的播放总时长
-    playTimes = new Map();
-    // 保存所有的动态纹理
-    anpgTextList = {};
-    // 获取动态纹理 需要每帧都获取一下
-    getTexture(path) {
-        // 如果 没有这个纹理就返回空同时开始加载这个纹理
-        if (!this.anpgTextList[path]) {
-            this.anpgTextList[path] = [];
-            this.loadApng(path);
-            return null;
-        }
-        else if (isEmpty(this.anpgTextList[path])) {
-            return null;
-        }
-        else {
-            const playTime = this.playTimes.get(path);
-            let currentTime = apngTextureManage.TimeTemp % playTime;
-            let i = 0;
-            while (this.anpgTextList[path][i] && currentTime > Number(this.anpgTextList[path][i].name)) {
-                currentTime -= Number(this.anpgTextList[path][i].name);
-                i++;
-            }
-            this.anpgTextList[path][i].needsUpdate = true;
-            return this.anpgTextList[path][i];
-        }
-    }
-    // 加载apng图片
-    async loadApng(url) {
-        const res = await axios.get(url, { method: "post", responseType: "blob" });
-        const blob = new Blob([res.data]);
-        const reader = new FileReader();
-        await new Promise((resolve) => {
-            reader.onload = () => resolve();
-            reader.readAsArrayBuffer(blob);
-        });
-        const apng = parseAPNG(reader.result);
-        // 存储播放时长
-        this.playTimes.set(url, apng.playTime);
-        // for (let i = 0; i < apng.frames.length; i++) {
-        //     const frame = apng.frames[i];
-        //     frame.createImage();
-        //     await new Promise(resolve => frame.imageElement!.onload = resolve);
-        // }
-        for (let i = 0; i < apng.frames.length; i++) {
-            const frame = apng.frames[i];
-            var blobUrl = URL.createObjectURL(frame.imageData);
-            const texture = apngTextureManage.TextureLoader.load(blobUrl);
-            texture.anisotropy = 16;
-            texture.wrapS = texture.wrapT = MirroredRepeatWrapping;
-            // export const RepeatWrapping: Wrapping;
-            // export const ClampToEdgeWrapping: Wrapping;
-            // export const MirroredRepeatWrapping: Wrapping;
-            // magFilter: TextureFilter;
-            // minFilter: TextureFilter;
-            texture.name = String(frame.delay);
-            texture.center.set(0.5, 0.5);
-            texture.repeat.set(apng.width / frame.width, apng.height / frame.height);
-            // texture.needsUpdate = true;
-            this.anpgTextList[url].push(texture);
-        }
-    }
-}
-const ApngTextureManage = new apngTextureManage();
-export default ApngTextureManage;

package/KeyFrameAnimation.d.ts

@@ -1,25 +0,0 @@
-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, import("three").Object3DEventMap>;
-    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 +0,0 @@
-/*
- * @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();
-    }
-}