three-base 2.0.130 → 2.0.134

package/Mirror.js

@@ -1,51 +1,51 @@
-/*
- * @Author: xiaosihan
- * @Date: 2023-08-04 17:17:15
- * @Last Modified by: xiaosihan
- * @Last Modified time: 2024-01-20 05:33:51
- */
-import { Color, DoubleSide, HalfFloatType, Matrix4, Mesh, PerspectiveCamera, Plane, PlaneGeometry, ShaderMaterial, Vector3, Vector4, WebGLRenderTarget } from "three";
-// 镜子模型
-export default class Mirror extends Mesh {
-    constructor(geometry = Mirror.geometry) {
-        super(geometry);
-    }
-    // 正方形网格
-    static geometry = (() => {
-        const geometry = new PlaneGeometry(10, 10, 1, 1);
-        return geometry;
-    })();
-    isReflector = true;
-    type = 'Reflector';
-    camera = new PerspectiveCamera();
-    reflectorPlane = new Plane();
-    normal = new Vector3();
-    reflectorWorldPosition = new Vector3();
-    cameraWorldPosition = new Vector3();
-    rotationMatrix = new Matrix4();
-    lookAtPosition = new Vector3(0, 0, -1);
-    clipPlane = new Vector4();
-    view = new Vector3();
-    target = new Vector3();
-    q = new Vector4();
-    textureMatrix = new Matrix4();
-    virtualCamera = this.camera;
-    renderTarget = new WebGLRenderTarget(2048, 2048, { samples: 0, type: HalfFloatType });
-    material = new ShaderMaterial({
-        uniforms: {
-            'color': {
-                value: new Color("#b6b6b6")
-            },
-            'tDiffuse': {
-                value: this.renderTarget.texture
-            },
-            'textureMatrix': {
-                value: this.textureMatrix
-            },
-            blurAmount: {
-                value: 0.5
-            } // 模糊程度，可以根据需求调整
-        },
+/*
+ * @Author: xiaosihan
+ * @Date: 2023-08-04 17:17:15
+ * @Last Modified by: xiaosihan
+ * @Last Modified time: 2024-01-20 05:33:51
+ */
+import { Color, DoubleSide, HalfFloatType, Matrix4, Mesh, PerspectiveCamera, Plane, PlaneGeometry, ShaderMaterial, Vector3, Vector4, WebGLRenderTarget } from "three";
+// 镜子模型
+export default class Mirror extends Mesh {
+    constructor(geometry = Mirror.geometry) {
+        super(geometry);
+    }
+    // 正方形网格
+    static geometry = (() => {
+        const geometry = new PlaneGeometry(10, 10, 1, 1);
+        return geometry;
+    })();
+    isReflector = true;
+    type = 'Reflector';
+    camera = new PerspectiveCamera();
+    reflectorPlane = new Plane();
+    normal = new Vector3();
+    reflectorWorldPosition = new Vector3();
+    cameraWorldPosition = new Vector3();
+    rotationMatrix = new Matrix4();
+    lookAtPosition = new Vector3(0, 0, -1);
+    clipPlane = new Vector4();
+    view = new Vector3();
+    target = new Vector3();
+    q = new Vector4();
+    textureMatrix = new Matrix4();
+    virtualCamera = this.camera;
+    renderTarget = new WebGLRenderTarget(2048, 2048, { samples: 0, type: HalfFloatType });
+    material = new ShaderMaterial({
+        uniforms: {
+            'color': {
+                value: new Color("#b6b6b6")
+            },
+            'tDiffuse': {
+                value: this.renderTarget.texture
+            },
+            'textureMatrix': {
+                value: this.textureMatrix
+            },
+            blurAmount: {
+                value: 0.5
+            } // 模糊程度，可以根据需求调整
+        },
         vertexShader: /* glsl */ `
                     uniform mat4 textureMatrix;
                     varying vec4 vUv;
@@ -61,7 +61,7 @@ export default class Mirror extends Mesh {
         
                         #include <logdepthbuf_vertex>
         
-                    }`,
+                    }`,
         fragmentShader: /* glsl */ `
             uniform vec3 color;
             uniform sampler2D tDiffuse;
@@ -104,93 +104,93 @@ export default class Mirror extends Mesh {
 
                 #include <tonemapping_fragment>
                 #include <colorspace_fragment>
-            }`,
-        depthTest: true,
-        depthWrite: true,
-        transparent: true,
-        side: DoubleSide
-    });
-    onBeforeRender = (renderer, scene, camera, geometry, material, group) => {
-        this.reflectorWorldPosition.setFromMatrixPosition(this.matrixWorld);
-        this.cameraWorldPosition.setFromMatrixPosition(camera.matrixWorld);
-        this.rotationMatrix.extractRotation(this.matrixWorld);
-        this.normal.set(0, 0, 1);
-        this.normal.applyMatrix4(this.rotationMatrix);
-        this.view.subVectors(this.reflectorWorldPosition, this.cameraWorldPosition);
-        // Avoid rendering when reflector is facing away
-        if (this.view.dot(this.normal) > 0) {
-            this.normal.set(0, 0, -1);
-        }
-        ;
-        this.view.reflect(this.normal).negate();
-        this.view.add(this.reflectorWorldPosition);
-        this.rotationMatrix.extractRotation(camera.matrixWorld);
-        this.lookAtPosition.set(0, 0, -1);
-        this.lookAtPosition.applyMatrix4(this.rotationMatrix);
-        this.lookAtPosition.add(this.cameraWorldPosition);
-        this.target.subVectors(this.reflectorWorldPosition, this.lookAtPosition);
-        this.target.reflect(this.normal).negate();
-        this.target.add(this.reflectorWorldPosition);
-        this.virtualCamera.position.copy(this.view);
-        this.virtualCamera.up.set(0, 1, 0);
-        this.virtualCamera.up.applyMatrix4(this.rotationMatrix);
-        this.virtualCamera.up.reflect(this.normal);
-        this.virtualCamera.lookAt(this.target);
-        this.virtualCamera.far = this.camera.far; // Used in WebGLBackground
-        this.virtualCamera.updateMatrixWorld();
-        this.virtualCamera.projectionMatrix.copy(camera.projectionMatrix);
-        // Update the texture matrix
-        this.textureMatrix.set(0.5, 0.0, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0);
-        this.textureMatrix.multiply(this.virtualCamera.projectionMatrix);
-        this.textureMatrix.multiply(this.virtualCamera.matrixWorldInverse);
-        this.textureMatrix.multiply(this.matrixWorld);
-        // Now update projection matrix with new clip plane, implementing code from: http://www.terathon.com/code/oblique.html
-        // Paper explaining this technique: http://www.terathon.com/lengyel/Lengyel-Oblique.pdf
-        this.reflectorPlane.setFromNormalAndCoplanarPoint(this.normal, this.reflectorWorldPosition);
-        this.reflectorPlane.applyMatrix4(this.virtualCamera.matrixWorldInverse);
-        this.clipPlane.set(this.reflectorPlane.normal.x, this.reflectorPlane.normal.y, this.reflectorPlane.normal.z, this.reflectorPlane.constant);
-        const projectionMatrix = this.virtualCamera.projectionMatrix;
-        this.q.x = (Math.sign(this.clipPlane.x) + projectionMatrix.elements[8]) / projectionMatrix.elements[0];
-        this.q.y = (Math.sign(this.clipPlane.y) + projectionMatrix.elements[9]) / projectionMatrix.elements[5];
-        this.q.z = -1.0;
-        this.q.w = (1.0 + projectionMatrix.elements[10]) / projectionMatrix.elements[14];
-        // Calculate the scaled plane vector
-        this.clipPlane.multiplyScalar(2.0 / this.clipPlane.dot(this.q));
-        // Replacing the third row of the projection matrix
-        projectionMatrix.elements[2] = this.clipPlane.x;
-        projectionMatrix.elements[6] = this.clipPlane.y;
-        projectionMatrix.elements[10] = this.clipPlane.z + 1.0 - 0.003;
-        projectionMatrix.elements[14] = this.clipPlane.w;
-        // Render
-        this.visible = false;
-        const currentRenderTarget = renderer.getRenderTarget();
-        const currentXrEnabled = renderer.xr.enabled;
-        const currentShadowAutoUpdate = renderer.shadowMap.autoUpdate;
-        renderer.xr.enabled = false; // Avoid camera modification
-        renderer.shadowMap.autoUpdate = false; // Avoid re-computing shadows
-        renderer.setRenderTarget(this.renderTarget);
-        renderer.state.buffers.depth.setMask(true); // make sure the depth buffer is writable so it can be properly cleared, see #18897
-        if (renderer.autoClear === false)
-            renderer.clear();
-        renderer.render(scene, this.virtualCamera);
-        renderer.xr.enabled = currentXrEnabled;
-        renderer.shadowMap.autoUpdate = currentShadowAutoUpdate;
-        renderer.setRenderTarget(currentRenderTarget);
-        // Restore viewport
-        //@ts-ignore
-        const viewport = this.camera.viewport;
-        if (viewport !== undefined) {
-            renderer.state.viewport(viewport);
-        }
-        this.visible = true;
-    };
-    getRenderTarget() {
-        return this.renderTarget;
-    }
-    ;
-    dispose() {
-        this.renderTarget.dispose();
-        // this.material.dispose();
-    }
-    ;
-}
+            }`,
+        depthTest: true,
+        depthWrite: true,
+        transparent: true,
+        side: DoubleSide
+    });
+    onBeforeRender = (renderer, scene, camera, geometry, material, group) => {
+        this.reflectorWorldPosition.setFromMatrixPosition(this.matrixWorld);
+        this.cameraWorldPosition.setFromMatrixPosition(camera.matrixWorld);
+        this.rotationMatrix.extractRotation(this.matrixWorld);
+        this.normal.set(0, 0, 1);
+        this.normal.applyMatrix4(this.rotationMatrix);
+        this.view.subVectors(this.reflectorWorldPosition, this.cameraWorldPosition);
+        // Avoid rendering when reflector is facing away
+        if (this.view.dot(this.normal) > 0) {
+            this.normal.set(0, 0, -1);
+        }
+        ;
+        this.view.reflect(this.normal).negate();
+        this.view.add(this.reflectorWorldPosition);
+        this.rotationMatrix.extractRotation(camera.matrixWorld);
+        this.lookAtPosition.set(0, 0, -1);
+        this.lookAtPosition.applyMatrix4(this.rotationMatrix);
+        this.lookAtPosition.add(this.cameraWorldPosition);
+        this.target.subVectors(this.reflectorWorldPosition, this.lookAtPosition);
+        this.target.reflect(this.normal).negate();
+        this.target.add(this.reflectorWorldPosition);
+        this.virtualCamera.position.copy(this.view);
+        this.virtualCamera.up.set(0, 1, 0);
+        this.virtualCamera.up.applyMatrix4(this.rotationMatrix);
+        this.virtualCamera.up.reflect(this.normal);
+        this.virtualCamera.lookAt(this.target);
+        this.virtualCamera.far = this.camera.far; // Used in WebGLBackground
+        this.virtualCamera.updateMatrixWorld();
+        this.virtualCamera.projectionMatrix.copy(camera.projectionMatrix);
+        // Update the texture matrix
+        this.textureMatrix.set(0.5, 0.0, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0);
+        this.textureMatrix.multiply(this.virtualCamera.projectionMatrix);
+        this.textureMatrix.multiply(this.virtualCamera.matrixWorldInverse);
+        this.textureMatrix.multiply(this.matrixWorld);
+        // Now update projection matrix with new clip plane, implementing code from: http://www.terathon.com/code/oblique.html
+        // Paper explaining this technique: http://www.terathon.com/lengyel/Lengyel-Oblique.pdf
+        this.reflectorPlane.setFromNormalAndCoplanarPoint(this.normal, this.reflectorWorldPosition);
+        this.reflectorPlane.applyMatrix4(this.virtualCamera.matrixWorldInverse);
+        this.clipPlane.set(this.reflectorPlane.normal.x, this.reflectorPlane.normal.y, this.reflectorPlane.normal.z, this.reflectorPlane.constant);
+        const projectionMatrix = this.virtualCamera.projectionMatrix;
+        this.q.x = (Math.sign(this.clipPlane.x) + projectionMatrix.elements[8]) / projectionMatrix.elements[0];
+        this.q.y = (Math.sign(this.clipPlane.y) + projectionMatrix.elements[9]) / projectionMatrix.elements[5];
+        this.q.z = -1.0;
+        this.q.w = (1.0 + projectionMatrix.elements[10]) / projectionMatrix.elements[14];
+        // Calculate the scaled plane vector
+        this.clipPlane.multiplyScalar(2.0 / this.clipPlane.dot(this.q));
+        // Replacing the third row of the projection matrix
+        projectionMatrix.elements[2] = this.clipPlane.x;
+        projectionMatrix.elements[6] = this.clipPlane.y;
+        projectionMatrix.elements[10] = this.clipPlane.z + 1.0 - 0.003;
+        projectionMatrix.elements[14] = this.clipPlane.w;
+        // Render
+        this.visible = false;
+        const currentRenderTarget = renderer.getRenderTarget();
+        const currentXrEnabled = renderer.xr.enabled;
+        const currentShadowAutoUpdate = renderer.shadowMap.autoUpdate;
+        renderer.xr.enabled = false; // Avoid camera modification
+        renderer.shadowMap.autoUpdate = false; // Avoid re-computing shadows
+        renderer.setRenderTarget(this.renderTarget);
+        renderer.state.buffers.depth.setMask(true); // make sure the depth buffer is writable so it can be properly cleared, see #18897
+        if (renderer.autoClear === false)
+            renderer.clear();
+        renderer.render(scene, this.virtualCamera);
+        renderer.xr.enabled = currentXrEnabled;
+        renderer.shadowMap.autoUpdate = currentShadowAutoUpdate;
+        renderer.setRenderTarget(currentRenderTarget);
+        // Restore viewport
+        //@ts-ignore
+        const viewport = this.camera.viewport;
+        if (viewport !== undefined) {
+            renderer.state.viewport(viewport);
+        }
+        this.visible = true;
+    };
+    getRenderTarget() {
+        return this.renderTarget;
+    }
+    ;
+    dispose() {
+        this.renderTarget.dispose();
+        // this.material.dispose();
+    }
+    ;
+}

package/PipeMesh/PathGeometry.d.ts

@@ -1,44 +1,44 @@
-import { Usage } from 'three/src/constants.js';
-import type { PathPointList } from './PathPointList.js';
-import { BufferGeometry } from 'three/src/core/BufferGeometry.js';
-export interface Options {
-    radius?: number;
-    width?: number;
-    progress?: number;
-    radialSegments?: number;
-    startRad?: number;
-    arrow?: boolean;
-    side?: 'both' | 'left' | 'right';
-}
-export interface PathGeometryParam {
-    pathPointList: PathPointList;
-    options: Options;
-    usage: Usage;
-    transparent: boolean;
-}
-/**
- * PathGeometry
- */
-declare class PathGeometry extends BufferGeometry {
-    /**
-     * @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);
-    _initByMaxVertex(maxVertex: number, generateUv2: boolean): void;
-    _initByData(pathPointList: PathPointList, options: Options, usage: Usage, generateUv2: boolean): void;
-    /**
-     * Update geometry by PathPointList instance
-     * @param {PathPointList} pathPointList
-     * @param {Object} options
-     * @param {Number} [options.width=0.1]
-     * @param {Number} [options.progress=1]
-     * @param {Boolean} [options.arrow=true]
-     * @param {String} [options.side='both'] - "left"/"right"/"both"
-     */
-    update(pathPointList: PathPointList, options: Options): void;
-    _resizeAttribute(name: string, len: number): void;
-    _resizeIndex(len: number): void;
-    _updateAttributes(position: Array<number>, normal: Array<number>, uv: Array<number>, uv2: Array<number> | null, indices: Array<number>): void;
-}
-export { PathGeometry };
+import { Usage } from 'three/src/constants.js';
+import type { PathPointList } from './PathPointList.js';
+import { BufferGeometry } from 'three/src/core/BufferGeometry.js';
+export interface Options {
+    radius?: number;
+    width?: number;
+    progress?: number;
+    radialSegments?: number;
+    startRad?: number;
+    arrow?: boolean;
+    side?: 'both' | 'left' | 'right';
+}
+export interface PathGeometryParam {
+    pathPointList: PathPointList;
+    options: Options;
+    usage: Usage;
+    transparent: boolean;
+}
+/**
+ * PathGeometry
+ */
+declare class PathGeometry extends BufferGeometry {
+    /**
+     * @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);
+    _initByMaxVertex(maxVertex: number, generateUv2: boolean): void;
+    _initByData(pathPointList: PathPointList, options: Options, usage: Usage, generateUv2: boolean): void;
+    /**
+     * Update geometry by PathPointList instance
+     * @param {PathPointList} pathPointList
+     * @param {Object} options
+     * @param {Number} [options.width=0.1]
+     * @param {Number} [options.progress=1]
+     * @param {Boolean} [options.arrow=true]
+     * @param {String} [options.side='both'] - "left"/"right"/"both"
+     */
+    update(pathPointList: PathPointList, options: Options): void;
+    _resizeAttribute(name: string, len: number): void;
+    _resizeIndex(len: number): void;
+    _updateAttributes(position: Array<number>, normal: Array<number>, uv: Array<number>, uv2: Array<number> | null, indices: Array<number>): void;
+}
+export { PathGeometry };