three-base 2.0.75 → 2.0.76

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,34 +1,34 @@
-import { AnimationAction, AnimationMixer, Clock, Group, Mesh, Object3D, Vector3 } from "three";
-export default class MeshBase extends Group {
-    constructor(url?: string);
-    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;
-    resoles: any[];
-    awaitLoaded(): 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);
+    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;
+    resoles: any[];
+    awaitLoaded(): 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;
+}

package/MeshBase.js

@@ -1,187 +1,187 @@
-import { AnimationMixer, Clock, Group, Vector3 } from "three";
-import threeUtils from "./threeUtils";
-import threeLoader from "./threeLoader";
-import * as SkeletonUtils from 'three/examples/jsm/utils/SkeletonUtils';
-// 模型基类
-export default class MeshBase extends Group {
-    constructor(url) {
-        super();
-        url && this.loadModel(url);
-    }
-    url = "";
-    // 模型对象
-    static models = new Map();
-    // 模型是否在加载中
-    static loadModeling = new Map();
-    // 加载完成
-    loaded = false;
-    // 是否有动画
-    hasAnimation = false;
-    //动画混合器
-    mixer;
-    //动画剪辑对象数组
-    animationActions = {};
-    // 获取文件名的后缀
-    getSuffix(filename) {
-        const match = filename.match(/\.([^\.]+)$/);
-        return match ? match[1].toLowerCase() : '';
-    }
-    // 如果url 是blob地址的话,就用suffix字段来制定模型的类型
-    async loadModel(url, filename = "") {
-        this.url = 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 = await threeLoader.loadModel(url, filename);
-            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));
-            }
-        }
-        await new Promise(resolve => requestAnimationFrame(resolve));
-        this.loaded = true;
-        // 加载完成事件
-        this.dispatchEvent({ type: "loaded" });
-    }
-    // 超出绘制区域时不绘制
-    frustumCulled = false;
-    // 创建阴影
-    castShadow = false;
-    // 接受阴影
-    receiveShadow = false;
-    // promise.resole 队列
-    resoles = [];
-    // 等待加载加载完成
-    async awaitLoaded() {
-        if (!this.loaded) {
-            await new Promise((resolve) => {
-                if (this.resoles.length === 0) {
-                    (async () => {
-                        while (!this.loaded) {
-                            await new Promise(resolve => requestAnimationFrame(resolve));
-                        }
-                        while (this.resoles.length > 0) {
-                            this.resoles.pop()();
-                        }
-                    })();
-                }
-                this.resoles.unshift(resolve);
-            });
-        }
-    }
-    //遍历模型
-    async traverseMesh(callback) {
-        // 等待加载完成
-        await this.awaitLoaded();
-        this.traverse(obj => {
-            const mesh = obj;
-            if (mesh.isMesh) {
-                callback(mesh);
-            }
-        });
-    }
-    clock = new Clock();
-    //设置动画的权重
-    async setClipActionWeight(weights = {}) {
-        // 等待加载完成
-        await this.awaitLoaded();
-        for (let key in this.animationActions) {
-            this.animationActions[key].weight = weights[key] || 0;
-        }
-    }
-    //获取动画列表
-    getAnimas() {
-        return Object.keys(this.animationActions);
-    }
-    //播放指定动画
-    setAnimas(anima = "") {
-        this.setClipActionWeight({ [anima]: 1 });
-    }
-    //停止所有动画
-    stop() {
-        this.setClipActionWeight();
-    }
-    updateMatrix() {
-        //播放动画
-        if (this.mixer) {
-            this.mixer.update(this.clock.getDelta());
-        }
-        // 深度应用属性
-        this.traverse(obj => {
-            const mesh = obj;
-            if (mesh.isMesh) {
-                mesh.frustumCulled = this.frustumCulled;
-                mesh.castShadow = this.castShadow;
-                mesh.receiveShadow = this.receiveShadow;
-            }
-        });
-        super.updateMatrix();
-    }
-    // 获取模型的尺寸
-    async getSize() {
-        await this.awaitLoaded();
-        return threeUtils.getSize(this);
-    }
-    // 居中
-    async center() {
-        await this.awaitLoaded();
-        threeUtils.center(this);
-    }
-    //底对齐
-    async alignBottom(y = 0) {
-        await this.awaitLoaded();
-        threeUtils.alignBottom(this, y);
-    }
-    // 放大到指定尺寸
-    async scaleTo(size = 1, key = ["x", "y", "z"]) {
-        await this.awaitLoaded();
-        threeUtils.scaleTo(this, size, key);
-    }
-    //按照法线拓展
-    expandBynormal(length) {
-        this.traverseMesh(mesh => {
-            // 没有法线就计算法线
-            mesh.geometry = mesh.geometry.clone();
-            if (!mesh.geometry.getAttribute("normal")) {
-                mesh.geometry.computeVertexNormals();
-            }
-            const normal = mesh.geometry.getAttribute("normal");
-            const position = mesh.geometry.getAttribute("position");
-            const v3 = new Vector3(0, 0, 0);
-            for (let i = 0; i < position.count; i++) {
-                v3.set(normal.getX(i), normal.getY(i), normal.getZ(i));
-                v3.setLength(length);
-                position.setXYZ(i, position.getX(i) + v3.x, position.getY(i) + v3.y, position.getZ(i) + v3.z);
-            }
-            position.needsUpdate = true;
-        });
-    }
-}
+import { AnimationMixer, Clock, Group, Vector3 } from "three";
+import threeUtils from "./threeUtils";
+import threeLoader from "./threeLoader";
+import * as SkeletonUtils from 'three/examples/jsm/utils/SkeletonUtils';
+// 模型基类
+export default class MeshBase extends Group {
+    constructor(url) {
+        super();
+        url && this.loadModel(url);
+    }
+    url = "";
+    // 模型对象
+    static models = new Map();
+    // 模型是否在加载中
+    static loadModeling = new Map();
+    // 加载完成
+    loaded = false;
+    // 是否有动画
+    hasAnimation = false;
+    //动画混合器
+    mixer;
+    //动画剪辑对象数组
+    animationActions = {};
+    // 获取文件名的后缀
+    getSuffix(filename) {
+        const match = filename.match(/\.([^\.]+)$/);
+        return match ? match[1].toLowerCase() : '';
+    }
+    // 如果url 是blob地址的话,就用suffix字段来制定模型的类型
+    async loadModel(url, filename = "") {
+        this.url = 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 = await threeLoader.loadModel(url, filename);
+            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));
+            }
+        }
+        await new Promise(resolve => requestAnimationFrame(resolve));
+        this.loaded = true;
+        // 加载完成事件
+        this.dispatchEvent({ type: "loaded" });
+    }
+    // 超出绘制区域时不绘制
+    frustumCulled = false;
+    // 创建阴影
+    castShadow = false;
+    // 接受阴影
+    receiveShadow = false;
+    // promise.resole 队列
+    resoles = [];
+    // 等待加载加载完成
+    async awaitLoaded() {
+        if (!this.loaded) {
+            await new Promise((resolve) => {
+                if (this.resoles.length === 0) {
+                    (async () => {
+                        while (!this.loaded) {
+                            await new Promise(resolve => requestAnimationFrame(resolve));
+                        }
+                        while (this.resoles.length > 0) {
+                            this.resoles.pop()();
+                        }
+                    })();
+                }
+                this.resoles.unshift(resolve);
+            });
+        }
+    }
+    //遍历模型
+    async traverseMesh(callback) {
+        // 等待加载完成
+        await this.awaitLoaded();
+        this.traverse(obj => {
+            const mesh = obj;
+            if (mesh.isMesh) {
+                callback(mesh);
+            }
+        });
+    }
+    clock = new Clock();
+    //设置动画的权重
+    async setClipActionWeight(weights = {}) {
+        // 等待加载完成
+        await this.awaitLoaded();
+        for (let key in this.animationActions) {
+            this.animationActions[key].weight = weights[key] || 0;
+        }
+    }
+    //获取动画列表
+    getAnimas() {
+        return Object.keys(this.animationActions);
+    }
+    //播放指定动画
+    setAnimas(anima = "") {
+        this.setClipActionWeight({ [anima]: 1 });
+    }
+    //停止所有动画
+    stop() {
+        this.setClipActionWeight();
+    }
+    updateMatrix() {
+        //播放动画
+        if (this.mixer) {
+            this.mixer.update(this.clock.getDelta());
+        }
+        // 深度应用属性
+        this.traverse(obj => {
+            const mesh = obj;
+            if (mesh.isMesh) {
+                mesh.frustumCulled = this.frustumCulled;
+                mesh.castShadow = this.castShadow;
+                mesh.receiveShadow = this.receiveShadow;
+            }
+        });
+        super.updateMatrix();
+    }
+    // 获取模型的尺寸
+    async getSize() {
+        await this.awaitLoaded();
+        return threeUtils.getSize(this);
+    }
+    // 居中
+    async center() {
+        await this.awaitLoaded();
+        threeUtils.center(this);
+    }
+    //底对齐
+    async alignBottom(y = 0) {
+        await this.awaitLoaded();
+        threeUtils.alignBottom(this, y);
+    }
+    // 放大到指定尺寸
+    async scaleTo(size = 1, key = ["x", "y", "z"]) {
+        await this.awaitLoaded();
+        threeUtils.scaleTo(this, size, key);
+    }
+    //按照法线拓展
+    expandBynormal(length) {
+        this.traverseMesh(mesh => {
+            // 没有法线就计算法线
+            mesh.geometry = mesh.geometry.clone();
+            if (!mesh.geometry.getAttribute("normal")) {
+                mesh.geometry.computeVertexNormals();
+            }
+            const normal = mesh.geometry.getAttribute("normal");
+            const position = mesh.geometry.getAttribute("position");
+            const v3 = new Vector3(0, 0, 0);
+            for (let i = 0; i < position.count; i++) {
+                v3.set(normal.getX(i), normal.getY(i), normal.getZ(i));
+                v3.setLength(length);
+                position.setXYZ(i, position.getX(i) + v3.x, position.getY(i) + v3.y, position.getZ(i) + v3.z);
+            }
+            position.needsUpdate = true;
+        });
+    }
+}

package/Mirror.d.ts

@@ -1,25 +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;
-}
+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;
+}