three-base 2.0.134 → 2.0.142

package/PipeMesh/PathTubeGeometry.d.ts

@@ -1,25 +1,25 @@
-import { Usage } from 'three/src/constants.js';
-import { PathGeometry, type Options, type PathGeometryParam } from './PathGeometry.js';
-import type { PathPointList } from './PathPointList.js';
-/**
- * PathTubeGeometry
- */
-declare class PathTubeGeometry extends PathGeometry {
-    /**
-     * @param {Object|Number} initData - If initData is number, geometry init by empty data and set it as the max vertex. If initData is Object, it contains pathPointList and options.
-     * @param {Boolean} [generateUv2=false]
-     */
-    constructor(initData: PathGeometryParam, generateUv2?: boolean);
-    _initByData(pathPointList: PathPointList, options: Options, usage: Usage, generateUv2: boolean): void;
-    /**
-     * Update geometry by PathPointList instance
-     * @param {PathPointList} pathPointList
-     * @param {Object} options
-     * @param {Number} [options.radius=0.1]
-     * @param {Number} [options.progress=1]
-     * @param {Boolean} [options.radialSegments=8]
-     * @param {String} [options.startRad=0]
-     */
-    update(pathPointList: PathPointList, options: Options): void;
-}
-export { PathTubeGeometry };
+import { Usage } from 'three/src/constants.js';
+import { PathGeometry, type Options, type PathGeometryParam } from './PathGeometry.js';
+import type { PathPointList } from './PathPointList.js';
+/**
+ * PathTubeGeometry
+ */
+declare class PathTubeGeometry extends PathGeometry {
+    /**
+     * @param {Object|Number} initData - If initData is number, geometry init by empty data and set it as the max vertex. If initData is Object, it contains pathPointList and options.
+     * @param {Boolean} [generateUv2=false]
+     */
+    constructor(initData: PathGeometryParam, generateUv2?: boolean);
+    _initByData(pathPointList: PathPointList, options: Options, usage: Usage, generateUv2: boolean): void;
+    /**
+     * Update geometry by PathPointList instance
+     * @param {PathPointList} pathPointList
+     * @param {Object} options
+     * @param {Number} [options.radius=0.1]
+     * @param {Number} [options.progress=1]
+     * @param {Boolean} [options.radialSegments=8]
+     * @param {String} [options.startRad=0]
+     */
+    update(pathPointList: PathPointList, options: Options): void;
+}
+export { PathTubeGeometry };

package/PipeMesh/PathTubeGeometry.js

@@ -1,130 +1,130 @@
-import { StaticDrawUsage } from 'three/src/constants.js';
-import { PathGeometry } from './PathGeometry.js';
-import { PathPoint } from './PathPoint.js';
-import { BufferAttribute } from 'three/src/core/BufferAttribute.js';
-import { Vector3 } from 'three/src/math/Vector3.js';
-/**
- * PathTubeGeometry
- */
-class PathTubeGeometry extends PathGeometry {
-    /**
-     * @param {Object|Number} initData - If initData is number, geometry init by empty data and set it as the max vertex. If initData is Object, it contains pathPointList and options.
-     * @param {Boolean} [generateUv2=false]
-     */
-    constructor(initData, generateUv2 = false) {
-        super(initData, generateUv2);
-    }
-    _initByData(pathPointList, options = {}, usage, generateUv2) {
-        const vertexData = generateTubeVertexData(pathPointList, options, generateUv2);
-        if (vertexData && vertexData.count !== 0) {
-            this.setAttribute('position', new BufferAttribute(new Float32Array(vertexData.position), 3).setUsage(usage || StaticDrawUsage));
-            this.setAttribute('normal', new BufferAttribute(new Float32Array(vertexData.normal), 3).setUsage(usage || StaticDrawUsage));
-            this.setAttribute('uv', new BufferAttribute(new Float32Array(vertexData.uv), 2).setUsage(usage || StaticDrawUsage));
-            if (generateUv2) {
-                this.setAttribute('uv2', new BufferAttribute(new Float32Array(vertexData.uv2), 2).setUsage(usage || StaticDrawUsage));
-            }
-            this.setIndex(vertexData.indices);
-        }
-        else {
-            this._initByMaxVertex(2, generateUv2);
-        }
-    }
-    /**
-     * Update geometry by PathPointList instance
-     * @param {PathPointList} pathPointList
-     * @param {Object} options
-     * @param {Number} [options.radius=0.1]
-     * @param {Number} [options.progress=1]
-     * @param {Boolean} [options.radialSegments=8]
-     * @param {String} [options.startRad=0]
-     */
-    update(pathPointList, options) {
-        const generateUv2 = !!this.getAttribute('uv2');
-        const vertexData = generateTubeVertexData(pathPointList, options, generateUv2);
-        if (vertexData) {
-            this._updateAttributes(vertexData.position, vertexData.normal, vertexData.uv, generateUv2 ? vertexData.uv2 : null, vertexData.indices);
-            this.drawRange.count = vertexData.count;
-        }
-        else {
-            this.drawRange.count = 0;
-        }
-    }
-}
-export { PathTubeGeometry };
-// Vertex Data Generate Functions
-function generateTubeVertexData(pathPointList, options, generateUv2 = false) {
-    const radius = options.radius || 0.1;
-    const progress = options.progress !== undefined ? options.progress : 1;
-    const radialSegments = Math.max(2, options.radialSegments || 8);
-    const startRad = options.startRad || 0;
-    const circum = radius * 2 * Math.PI;
-    const totalDistance = pathPointList.distance();
-    const progressDistance = progress * totalDistance;
-    if (progressDistance == 0) {
-        return null;
-    }
-    let count = 0;
-    // modify data
-    const position = [];
-    const normal = [];
-    const uv = [];
-    const uv2 = [];
-    const indices = [];
-    let verticesCount = 0;
-    const normalDir = new Vector3();
-    function addVertices(pathPoint, radius, radialSegments) {
-        const first = position.length === 0;
-        const uvDist = pathPoint.dist / circum;
-        const uvDist2 = pathPoint.dist / totalDistance;
-        for (let r = 0; r <= radialSegments; r++) {
-            let _r = r;
-            if (_r == radialSegments) {
-                _r = 0;
-            }
-            normalDir
-                .copy(pathPoint.up)
-                .applyAxisAngle(pathPoint.dir, startRad + (Math.PI * 2 * _r) / radialSegments)
-                .normalize();
-            position.push(pathPoint.pos.x + normalDir.x * radius * pathPoint.widthScale, pathPoint.pos.y + normalDir.y * radius * pathPoint.widthScale, pathPoint.pos.z + normalDir.z * radius * pathPoint.widthScale);
-            normal.push(normalDir.x, normalDir.y, normalDir.z);
-            uv.push(uvDist, r / radialSegments);
-            if (generateUv2) {
-                uv2.push(uvDist2, r / radialSegments);
-            }
-            verticesCount++;
-        }
-        if (!first) {
-            const begin1 = verticesCount - (radialSegments + 1) * 2;
-            const begin2 = verticesCount - (radialSegments + 1);
-            for (let i = 0; i < radialSegments; i++) {
-                indices.push(begin2 + i, begin1 + i, begin1 + i + 1, begin2 + i, begin1 + i + 1, begin2 + i + 1);
-                count += 6;
-            }
-        }
-    }
-    if (progressDistance > 0) {
-        for (let i = 0; i < pathPointList.count; i++) {
-            const pathPoint = pathPointList.array[i];
-            if (pathPoint.dist > progressDistance) {
-                const prevPoint = pathPointList.array[i - 1];
-                const lastPoint = new PathPoint();
-                // linear lerp for progress
-                const alpha = (progressDistance - prevPoint.dist) / (pathPoint.dist - prevPoint.dist);
-                lastPoint.lerpPathPoints(prevPoint, pathPoint, alpha);
-                addVertices(lastPoint, radius, radialSegments);
-                break;
-            }
-            else {
-                addVertices(pathPoint, radius, radialSegments);
-            }
-        }
-    }
-    return {
-        position,
-        normal,
-        uv,
-        uv2,
-        indices,
-        count,
-    };
-}
+import { StaticDrawUsage } from 'three/src/constants.js';
+import { PathGeometry } from './PathGeometry.js';
+import { PathPoint } from './PathPoint.js';
+import { BufferAttribute } from 'three/src/core/BufferAttribute.js';
+import { Vector3 } from 'three/src/math/Vector3.js';
+/**
+ * PathTubeGeometry
+ */
+class PathTubeGeometry extends PathGeometry {
+    /**
+     * @param {Object|Number} initData - If initData is number, geometry init by empty data and set it as the max vertex. If initData is Object, it contains pathPointList and options.
+     * @param {Boolean} [generateUv2=false]
+     */
+    constructor(initData, generateUv2 = false) {
+        super(initData, generateUv2);
+    }
+    _initByData(pathPointList, options = {}, usage, generateUv2) {
+        const vertexData = generateTubeVertexData(pathPointList, options, generateUv2);
+        if (vertexData && vertexData.count !== 0) {
+            this.setAttribute('position', new BufferAttribute(new Float32Array(vertexData.position), 3).setUsage(usage || StaticDrawUsage));
+            this.setAttribute('normal', new BufferAttribute(new Float32Array(vertexData.normal), 3).setUsage(usage || StaticDrawUsage));
+            this.setAttribute('uv', new BufferAttribute(new Float32Array(vertexData.uv), 2).setUsage(usage || StaticDrawUsage));
+            if (generateUv2) {
+                this.setAttribute('uv2', new BufferAttribute(new Float32Array(vertexData.uv2), 2).setUsage(usage || StaticDrawUsage));
+            }
+            this.setIndex(vertexData.indices);
+        }
+        else {
+            this._initByMaxVertex(2, generateUv2);
+        }
+    }
+    /**
+     * Update geometry by PathPointList instance
+     * @param {PathPointList} pathPointList
+     * @param {Object} options
+     * @param {Number} [options.radius=0.1]
+     * @param {Number} [options.progress=1]
+     * @param {Boolean} [options.radialSegments=8]
+     * @param {String} [options.startRad=0]
+     */
+    update(pathPointList, options) {
+        const generateUv2 = !!this.getAttribute('uv2');
+        const vertexData = generateTubeVertexData(pathPointList, options, generateUv2);
+        if (vertexData) {
+            this._updateAttributes(vertexData.position, vertexData.normal, vertexData.uv, generateUv2 ? vertexData.uv2 : null, vertexData.indices);
+            this.drawRange.count = vertexData.count;
+        }
+        else {
+            this.drawRange.count = 0;
+        }
+    }
+}
+export { PathTubeGeometry };
+// Vertex Data Generate Functions
+function generateTubeVertexData(pathPointList, options, generateUv2 = false) {
+    const radius = options.radius || 0.1;
+    const progress = options.progress !== undefined ? options.progress : 1;
+    const radialSegments = Math.max(2, options.radialSegments || 8);
+    const startRad = options.startRad || 0;
+    const circum = radius * 2 * Math.PI;
+    const totalDistance = pathPointList.distance();
+    const progressDistance = progress * totalDistance;
+    if (progressDistance == 0) {
+        return null;
+    }
+    let count = 0;
+    // modify data
+    const position = [];
+    const normal = [];
+    const uv = [];
+    const uv2 = [];
+    const indices = [];
+    let verticesCount = 0;
+    const normalDir = new Vector3();
+    function addVertices(pathPoint, radius, radialSegments) {
+        const first = position.length === 0;
+        const uvDist = pathPoint.dist / circum;
+        const uvDist2 = pathPoint.dist / totalDistance;
+        for (let r = 0; r <= radialSegments; r++) {
+            let _r = r;
+            if (_r == radialSegments) {
+                _r = 0;
+            }
+            normalDir
+                .copy(pathPoint.up)
+                .applyAxisAngle(pathPoint.dir, startRad + (Math.PI * 2 * _r) / radialSegments)
+                .normalize();
+            position.push(pathPoint.pos.x + normalDir.x * radius * pathPoint.widthScale, pathPoint.pos.y + normalDir.y * radius * pathPoint.widthScale, pathPoint.pos.z + normalDir.z * radius * pathPoint.widthScale);
+            normal.push(normalDir.x, normalDir.y, normalDir.z);
+            uv.push(uvDist, r / radialSegments);
+            if (generateUv2) {
+                uv2.push(uvDist2, r / radialSegments);
+            }
+            verticesCount++;
+        }
+        if (!first) {
+            const begin1 = verticesCount - (radialSegments + 1) * 2;
+            const begin2 = verticesCount - (radialSegments + 1);
+            for (let i = 0; i < radialSegments; i++) {
+                indices.push(begin2 + i, begin1 + i, begin1 + i + 1, begin2 + i, begin1 + i + 1, begin2 + i + 1);
+                count += 6;
+            }
+        }
+    }
+    if (progressDistance > 0) {
+        for (let i = 0; i < pathPointList.count; i++) {
+            const pathPoint = pathPointList.array[i];
+            if (pathPoint.dist > progressDistance) {
+                const prevPoint = pathPointList.array[i - 1];
+                const lastPoint = new PathPoint();
+                // linear lerp for progress
+                const alpha = (progressDistance - prevPoint.dist) / (pathPoint.dist - prevPoint.dist);
+                lastPoint.lerpPathPoints(prevPoint, pathPoint, alpha);
+                addVertices(lastPoint, radius, radialSegments);
+                break;
+            }
+            else {
+                addVertices(pathPoint, radius, radialSegments);
+            }
+        }
+    }
+    return {
+        position,
+        normal,
+        uv,
+        uv2,
+        indices,
+        count,
+    };
+}

package/PipeMesh/PathTubeGeometry.ts

@@ -0,0 +1,146 @@
+import { StaticDrawUsage, Usage } from 'three/src/constants.js';
+import { PathGeometry, type Options, type PathGeometryParam } from './PathGeometry.js';
+import { PathPoint } from './PathPoint.js';
+import type { PathPointList } from './PathPointList.js';
+import { BufferAttribute } from 'three/src/core/BufferAttribute.js';
+import { Vector3 } from 'three/src/math/Vector3.js';
+
+interface TubeVertexData {
+    position: Array<number>;
+    normal: Array<number>;
+    uv: Array<number>;
+    uv2: Array<number>;
+    indices: Array<number>;
+    count: number;
+}
+
+/**
+ * PathTubeGeometry
+ */
+class PathTubeGeometry extends PathGeometry {
+    /**
+     * @param {Object|Number} initData - If initData is number, geometry init by empty data and set it as the max vertex. If initData is Object, it contains pathPointList and options.
+     * @param {Boolean} [generateUv2=false]
+     */
+    constructor(initData: PathGeometryParam, generateUv2: boolean = false) {
+        super(initData, generateUv2);
+    }
+
+    _initByData(pathPointList: PathPointList, options: Options = {}, usage: Usage, generateUv2: boolean): void {
+        const vertexData = generateTubeVertexData(pathPointList, options, generateUv2);
+        if (vertexData && vertexData.count !== 0) {
+            this.setAttribute('position', new BufferAttribute(new Float32Array(vertexData.position), 3).setUsage(usage || StaticDrawUsage));
+            this.setAttribute('normal', new BufferAttribute(new Float32Array(vertexData.normal), 3).setUsage(usage || StaticDrawUsage));
+            this.setAttribute('uv', new BufferAttribute(new Float32Array(vertexData.uv), 2).setUsage(usage || StaticDrawUsage));
+            if (generateUv2) {
+                this.setAttribute('uv2', new BufferAttribute(new Float32Array(vertexData.uv2), 2).setUsage(usage || StaticDrawUsage));
+            }
+            this.setIndex(vertexData.indices);
+        }
+        else {
+            this._initByMaxVertex(2, generateUv2);
+        }
+    }
+
+    /**
+     * Update geometry by PathPointList instance
+     * @param {PathPointList} pathPointList
+     * @param {Object} options
+     * @param {Number} [options.radius=0.1]
+     * @param {Number} [options.progress=1]
+     * @param {Boolean} [options.radialSegments=8]
+     * @param {String} [options.startRad=0]
+     */
+    update(pathPointList: PathPointList, options: Options): void {
+        const generateUv2 = !!this.getAttribute('uv2');
+        const vertexData = generateTubeVertexData(pathPointList, options, generateUv2);
+        if (vertexData) {
+            this._updateAttributes(vertexData.position, vertexData.normal, vertexData.uv, generateUv2 ? vertexData.uv2 : null, vertexData.indices);
+            this.drawRange.count = vertexData.count;
+        }
+        else {
+            this.drawRange.count = 0;
+        }
+    }
+}
+
+export { PathTubeGeometry };
+
+// Vertex Data Generate Functions
+function generateTubeVertexData(pathPointList: PathPointList, options: Options, generateUv2: boolean = false): TubeVertexData | null {
+    const radius = options.radius || 0.1;
+    const progress = options.progress !== undefined ? options.progress : 1;
+    const radialSegments = Math.max(2, options.radialSegments || 8);
+    const startRad = options.startRad || 0;
+    const circum = radius * 2 * Math.PI;
+    const totalDistance = pathPointList.distance();
+    const progressDistance = progress * totalDistance;
+    if (progressDistance == 0) {
+        return null;
+    }
+    let count = 0;
+    // modify data
+    const position: Array<number> = [];
+    const normal: Array<number> = [];
+    const uv: Array<number> = [];
+    const uv2: Array<number> = [];
+    const indices: Array<number> = [];
+    let verticesCount = 0;
+    const normalDir = new Vector3();
+
+    function addVertices(pathPoint: PathPoint, radius: number, radialSegments: number): void {
+        const first = position.length === 0;
+        const uvDist = pathPoint.dist / circum;
+        const uvDist2 = pathPoint.dist / totalDistance;
+        for (let r = 0; r <= radialSegments; r++) {
+            let _r = r;
+            if (_r == radialSegments) {
+                _r = 0;
+            }
+            normalDir
+                .copy(pathPoint.up)
+                .applyAxisAngle(pathPoint.dir, startRad + (Math.PI * 2 * _r) / radialSegments)
+                .normalize();
+            position.push(pathPoint.pos.x + normalDir.x * radius * pathPoint.widthScale, pathPoint.pos.y + normalDir.y * radius * pathPoint.widthScale, pathPoint.pos.z + normalDir.z * radius * pathPoint.widthScale);
+            normal.push(normalDir.x, normalDir.y, normalDir.z);
+            uv.push(uvDist, r / radialSegments);
+            if (generateUv2) {
+                uv2.push(uvDist2, r / radialSegments);
+            }
+            verticesCount++;
+        }
+        if (!first) {
+            const begin1 = verticesCount - (radialSegments + 1) * 2;
+            const begin2 = verticesCount - (radialSegments + 1);
+            for (let i = 0; i < radialSegments; i++) {
+                indices.push(begin2 + i, begin1 + i, begin1 + i + 1, begin2 + i, begin1 + i + 1, begin2 + i + 1);
+                count += 6;
+            }
+        }
+    }
+    if (progressDistance > 0) {
+        for (let i = 0; i < pathPointList.count; i++) {
+            const pathPoint = pathPointList.array[i];
+            if (pathPoint.dist > progressDistance) {
+                const prevPoint = pathPointList.array[i - 1];
+                const lastPoint = new PathPoint();
+                // linear lerp for progress
+                const alpha = (progressDistance - prevPoint.dist) / (pathPoint.dist - prevPoint.dist);
+                lastPoint.lerpPathPoints(prevPoint, pathPoint, alpha);
+                addVertices(lastPoint, radius, radialSegments);
+                break;
+            }
+            else {
+                addVertices(pathPoint, radius, radialSegments);
+            }
+        }
+    }
+    return {
+        position,
+        normal,
+        uv,
+        uv2,
+        indices,
+        count,
+    };
+}

package/PipeMesh/PipeMesh.d.ts

@@ -1,25 +1,25 @@
-import { Material, Mesh, Vector3 } from "three";
-import { PathPointList } from "./PathPointList";
-import { PathTubeGeometry } from "./PathTubeGeometry";
-export type PipeMeshProps = {
-    vector3s: Array<Vector3>;
-    radius?: number;
-    segments?: number;
-};
-/**
- * 创建基础的管道模型
- */
-export default class PipeMesh extends Mesh<PathTubeGeometry, Material> {
-    constructor(props: PipeMeshProps);
-    type: string;
-    vector3s: Array<Vector3>;
-    radius: number;
-    segments: number;
-    pathPointList: PathPointList;
-    material: Material;
-    set(props: PipeMeshProps): void;
-    setVector(i: number, vector: Vector3): void;
-    getVector(i: number): Vector3;
-    setLatestVector(vector: Vector3): void;
-    getLatestVector(): Vector3;
-}
+import { Mesh, Vector3, Material } from "three";
+import { PathPointList } from "./PathPointList";
+import { PathTubeGeometry } from "./PathTubeGeometry";
+export type PipeMeshProps = {
+    vector3s: Array<Vector3>;
+    radius?: number;
+    segments?: number;
+};
+/**
+ * 创建基础的管道模型
+ */
+export default class PipeMesh extends Mesh<PathTubeGeometry, Material> {
+    constructor(props: PipeMeshProps);
+    type: string;
+    vector3s: Array<Vector3>;
+    radius: number;
+    segments: number;
+    pathPointList: PathPointList;
+    material: Material;
+    set(props: PipeMeshProps): void;
+    setVector(i: number, vector: Vector3): void;
+    getVector(i: number): Vector3;
+    setLatestVector(vector: Vector3): void;
+    getLatestVector(): Vector3;
+}

package/PipeMesh/PipeMesh.js

@@ -1,63 +1,63 @@
-/*
- * @Author: xiaosihan
- * @Date: 2022-02-16 23:13:14
- * @Last Modified by: xiaosihan
- * @Last Modified time: 2024-11-23 13:06:54
- */
-import { DoubleSide, DynamicDrawUsage, Mesh, MeshLambertMaterial, } from "three";
-import { PathPointList } from "./PathPointList";
-import { PathTubeGeometry } from "./PathTubeGeometry";
-/**
- * 创建基础的管道模型
- */
-export default class PipeMesh extends Mesh {
-    constructor(props) {
-        super();
-        this.set(props);
-    }
-    type = "pipemesh";
-    vector3s = []; // 管道上的点
-    radius = 1; //管道的半径
-    segments = 10; //管道的段数
-    pathPointList = new PathPointList();
-    material = new MeshLambertMaterial({
-        side: DoubleSide,
-        color: "#fff",
-    });
-    // 设置数据
-    set(props) {
-        this.vector3s = props.vector3s;
-        this.radius = props.radius || 1;
-        this.segments = props.segments || 10;
-        this.pathPointList.set(this.vector3s, props.radius * 2, 10);
-        this.geometry = new PathTubeGeometry({
-            pathPointList: this.pathPointList,
-            options: {
-                arrow: true,
-                progress: 1,
-                radius: props.radius,
-                radialSegments: this.segments,
-            },
-            usage: DynamicDrawUsage,
-            transparent: true,
-        });
-    }
-    // 设置指定点的坐标
-    setVector(i, vector) {
-        this.vector3s[i].copy(vector);
-        this.pathPointList.set(this.vector3s, this.radius * 2, this.segments);
-        this.geometry.update(this.pathPointList, { radius: this.radius });
-    }
-    // 获取指定点的坐标
-    getVector(i) {
-        return this.vector3s[i];
-    }
-    // 设置最后一个点的坐标
-    setLatestVector(vector) {
-        this.setVector(this.vector3s.length - 1, vector);
-    }
-    // 回去最后一个点的坐标
-    getLatestVector() {
-        return this.getVector(this.vector3s.length - 1);
-    }
-}
+/*
+ * @Author: xiaosihan
+ * @Date: 2022-02-16 23:13:14
+ * @Last Modified by: xiaosihan
+ * @Last Modified time: 2024-11-23 13:06:54
+ */
+import { DoubleSide, DynamicDrawUsage, Mesh, MeshLambertMaterial } from "three";
+import { PathPointList } from "./PathPointList";
+import { PathTubeGeometry } from "./PathTubeGeometry";
+/**
+ * 创建基础的管道模型
+ */
+export default class PipeMesh extends Mesh {
+    constructor(props) {
+        super();
+        this.set(props);
+    }
+    type = "pipemesh";
+    vector3s = []; // 管道上的点
+    radius = 1; //管道的半径
+    segments = 10; //管道的段数
+    pathPointList = new PathPointList();
+    material = new MeshLambertMaterial({
+        side: DoubleSide,
+        color: "#fff",
+    });
+    // 设置数据
+    set(props) {
+        this.vector3s = props.vector3s;
+        this.radius = props.radius || 1;
+        this.segments = props.segments || 10;
+        this.pathPointList.set(this.vector3s, props.radius * 2, 10);
+        this.geometry = new PathTubeGeometry({
+            pathPointList: this.pathPointList,
+            options: {
+                arrow: true,
+                progress: 1,
+                radius: props.radius,
+                radialSegments: this.segments,
+            },
+            usage: DynamicDrawUsage,
+            transparent: true,
+        });
+    }
+    // 设置指定点的坐标
+    setVector(i, vector) {
+        this.vector3s[i].copy(vector);
+        this.pathPointList.set(this.vector3s, this.radius * 2, this.segments);
+        this.geometry.update(this.pathPointList, { radius: this.radius });
+    }
+    // 获取指定点的坐标
+    getVector(i) {
+        return this.vector3s[i];
+    }
+    // 设置最后一个点的坐标
+    setLatestVector(vector) {
+        this.setVector(this.vector3s.length - 1, vector);
+    }
+    // 回去最后一个点的坐标
+    getLatestVector() {
+        return this.getVector(this.vector3s.length - 1);
+    }
+}